xref: /llvm-project/llvm/unittests/Support/AlignmentTest.cpp (revision d3cf49e984c12981f7d6df1c47b60fbeb71092ab)
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).previous(), Value / 2);
81     }
82   }
83 }
84 
85 TEST(AlignmentTest, AlignTo) {
86   struct {
87     uint64_t alignment;
88     uint64_t offset;
89     uint64_t rounded;
90     const void *forgedAddr() const {
91       //  A value of any integral or enumeration type can be converted to a
92       //  pointer type.
93       return reinterpret_cast<const void *>(offset);
94     }
95   } kTests[] = {
96       // Align
97       {1, 0, 0},
98       {1, 1, 1},
99       {1, 5, 5},
100       {2, 0, 0},
101       {2, 1, 2},
102       {2, 2, 2},
103       {2, 7, 8},
104       {2, 16, 16},
105       {4, 0, 0},
106       {4, 1, 4},
107       {4, 4, 4},
108       {4, 6, 8},
109   };
110   for (const auto &T : kTests) {
111     Align A = Align(T.alignment);
112     EXPECT_EQ(alignTo(T.offset, A), T.rounded);
113     EXPECT_EQ(alignAddr(T.forgedAddr(), A), T.rounded);
114   }
115 }
116 
117 TEST(AlignmentTest, AlignToWithSkew) {
118   EXPECT_EQ(alignTo(5, Align(8), 0), alignTo(5, Align(8)));
119   EXPECT_EQ(alignTo(5, Align(8), 7), 7U);
120   EXPECT_EQ(alignTo(17, Align(8), 1), 17U);
121   EXPECT_EQ(alignTo(~0LL, Align(8), 3), 3U);
122 }
123 
124 TEST(AlignmentTest, Log2) {
125   for (uint64_t Value : getValidAlignments()) {
126     EXPECT_EQ(Log2(Align(Value)), Log2_64(Value));
127   }
128 }
129 
130 TEST(AlignmentTest, MinAlign) {
131   struct {
132     uint64_t A;
133     uint64_t B;
134     uint64_t MinAlign;
135   } kTests[] = {
136       // MaybeAlign
137       {0, 0, 0},
138       {0, 8, 8},
139       {2, 0, 2},
140       // MaybeAlign / Align
141       {1, 2, 1},
142       {8, 4, 4},
143   };
144   for (const auto &T : kTests) {
145     EXPECT_EQ(commonAlignment(MaybeAlign(T.A), MaybeAlign(T.B)), T.MinAlign);
146     EXPECT_EQ(MinAlign(T.A, T.B), T.MinAlign);
147     if (T.A) {
148       EXPECT_EQ(commonAlignment(Align(T.A), MaybeAlign(T.B)), T.MinAlign);
149     }
150     if (T.B) {
151       EXPECT_EQ(commonAlignment(MaybeAlign(T.A), Align(T.B)), T.MinAlign);
152     }
153     if (T.A && T.B) {
154       EXPECT_EQ(commonAlignment(Align(T.A), Align(T.B)), T.MinAlign);
155     }
156   }
157 }
158 
159 TEST(AlignmentTest, Encode_Decode) {
160   for (uint64_t Value : getValidAlignments()) {
161     {
162       Align Actual(Value);
163       Align Expected = decodeMaybeAlign(encode(Actual)).getValue();
164       EXPECT_EQ(Expected, Actual);
165     }
166     {
167       MaybeAlign Actual(Value);
168       MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
169       EXPECT_EQ(Expected, Actual);
170     }
171   }
172   MaybeAlign Actual(0);
173   MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
174   EXPECT_EQ(Expected, Actual);
175 }
176 
177 TEST(AlignmentTest, isAligned_isAddrAligned) {
178   struct {
179     uint64_t alignment;
180     uint64_t offset;
181     bool isAligned;
182     const void *forgedAddr() const {
183       //  A value of any integral or enumeration type can be converted to a
184       //  pointer type.
185       return reinterpret_cast<const void *>(offset);
186     }
187   } kTests[] = {
188       {1, 0, true},  {1, 1, true},  {1, 5, true},  {2, 0, true},
189       {2, 1, false}, {2, 2, true},  {2, 7, false}, {2, 16, true},
190       {4, 0, true},  {4, 1, false}, {4, 4, true},  {4, 6, false},
191   };
192   for (const auto &T : kTests) {
193     MaybeAlign A(T.alignment);
194     // Test Align
195     if (A) {
196       EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned);
197       EXPECT_EQ(isAddrAligned(A.getValue(), T.forgedAddr()), T.isAligned);
198     }
199   }
200 }
201 
202 TEST(AlignmentTest, offsetToAlignment) {
203   struct {
204     uint64_t alignment;
205     uint64_t offset;
206     uint64_t alignedOffset;
207     const void *forgedAddr() const {
208       //  A value of any integral or enumeration type can be converted to a
209       //  pointer type.
210       return reinterpret_cast<const void *>(offset);
211     }
212   } kTests[] = {
213       {1, 0, 0}, {1, 1, 0},  {1, 5, 0}, {2, 0, 0}, {2, 1, 1}, {2, 2, 0},
214       {2, 7, 1}, {2, 16, 0}, {4, 0, 0}, {4, 1, 3}, {4, 4, 0}, {4, 6, 2},
215   };
216   for (const auto &T : kTests) {
217     const Align A(T.alignment);
218     EXPECT_EQ(offsetToAlignment(T.offset, A), T.alignedOffset);
219     EXPECT_EQ(offsetToAlignedAddr(T.forgedAddr(), A), T.alignedOffset);
220   }
221 }
222 
223 TEST(AlignmentTest, AlignComparisons) {
224   std::vector<uint64_t> ValidAlignments = getValidAlignments();
225   std::sort(ValidAlignments.begin(), ValidAlignments.end());
226   for (size_t I = 1; I < ValidAlignments.size(); ++I) {
227     assert(I >= 1);
228     const Align A(ValidAlignments[I - 1]);
229     const Align B(ValidAlignments[I]);
230     EXPECT_EQ(A, A);
231     EXPECT_NE(A, B);
232     EXPECT_LT(A, B);
233     EXPECT_GT(B, A);
234     EXPECT_LE(A, B);
235     EXPECT_GE(B, A);
236     EXPECT_LE(A, A);
237     EXPECT_GE(A, A);
238 
239     EXPECT_EQ(A, A.value());
240     EXPECT_NE(A, B.value());
241     EXPECT_LT(A, B.value());
242     EXPECT_GT(B, A.value());
243     EXPECT_LE(A, B.value());
244     EXPECT_GE(B, A.value());
245     EXPECT_LE(A, A.value());
246     EXPECT_GE(A, A.value());
247 
248     EXPECT_EQ(std::max(A, B), B);
249     EXPECT_EQ(std::min(A, B), A);
250 
251     const MaybeAlign MA(ValidAlignments[I - 1]);
252     const MaybeAlign MB(ValidAlignments[I]);
253     EXPECT_EQ(MA, MA);
254     EXPECT_NE(MA, MB);
255 
256     EXPECT_EQ(MA, MA ? (*MA).value() : 0);
257     EXPECT_NE(MA, MB ? (*MB).value() : 0);
258 
259     EXPECT_EQ(std::max(A, B), B);
260     EXPECT_EQ(std::min(A, B), A);
261   }
262 }
263 
264 TEST(AlignmentTest, AssumeAligned) {
265   EXPECT_EQ(assumeAligned(0), Align(1));
266   EXPECT_EQ(assumeAligned(0), Align());
267   EXPECT_EQ(assumeAligned(1), Align(1));
268   EXPECT_EQ(assumeAligned(1), Align());
269 }
270 
271 // Death tests reply on assert which is disabled in release mode.
272 #ifndef NDEBUG
273 
274 // We use a subset of valid alignments for DEATH_TESTs as they are particularly
275 // slow.
276 std::vector<uint64_t> getValidAlignmentsForDeathTest() {
277   return {1, 1ULL << 31, 1ULL << 63};
278 }
279 
280 std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; }
281 
282 TEST(AlignmentDeathTest, CantConvertUnsetMaybe) {
283   EXPECT_DEATH((MaybeAlign(0).getValue()), ".*");
284 }
285 
286 TEST(AlignmentDeathTest, InvalidCTors) {
287   EXPECT_DEATH((Align(0)), "Value must not be 0");
288   for (uint64_t Value : getNonPowerOfTwo()) {
289     EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2");
290     EXPECT_DEATH((MaybeAlign(Value)),
291                  "Alignment is neither 0 nor a power of 2");
292   }
293 }
294 
295 TEST(AlignmentDeathTest, ComparisonsWithZero) {
296   for (uint64_t Value : getValidAlignmentsForDeathTest()) {
297     EXPECT_DEATH((void)(Align(Value) == 0), ".* should be defined");
298     EXPECT_DEATH((void)(Align(Value) != 0), ".* should be defined");
299     EXPECT_DEATH((void)(Align(Value) >= 0), ".* should be defined");
300     EXPECT_DEATH((void)(Align(Value) <= 0), ".* should be defined");
301     EXPECT_DEATH((void)(Align(Value) > 0), ".* should be defined");
302     EXPECT_DEATH((void)(Align(Value) < 0), ".* should be defined");
303   }
304 }
305 
306 TEST(AlignmentDeathTest, CompareMaybeAlignToZero) {
307   for (uint64_t Value : getValidAlignmentsForDeathTest()) {
308     // MaybeAlign is allowed to be == or != 0
309     (void)(MaybeAlign(Value) == 0);
310     (void)(MaybeAlign(Value) != 0);
311   }
312 }
313 
314 TEST(AlignmentDeathTest, AlignAddr) {
315   const void *const unaligned_high_ptr =
316       reinterpret_cast<const void *>(std::numeric_limits<uintptr_t>::max() - 1);
317   EXPECT_DEATH(alignAddr(unaligned_high_ptr, Align(16)), "Overflow");
318 }
319 
320 #endif // NDEBUG
321 
322 } // end anonymous namespace
323 
324 #ifdef _MSC_VER
325 #pragma warning(pop)
326 #endif
327