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 std::vector<uint64_t> getValidAlignments() {
25   std::vector<uint64_t> Out;
26   for (size_t Shift = 0; Shift < 64; ++Shift)
27     Out.push_back(1ULL << Shift);
28   return Out;
29 }
30 
31 TEST(AlignmentTest, AlignDefaultCTor) { EXPECT_EQ(Align().value(), 1ULL); }
32 
33 TEST(AlignmentTest, MaybeAlignDefaultCTor) {
34   EXPECT_FALSE(MaybeAlign().hasValue());
35 }
36 
37 TEST(AlignmentTest, ValidCTors) {
38   for (uint64_t Value : getValidAlignments()) {
39     EXPECT_EQ(Align(Value).value(), Value);
40     EXPECT_EQ((*MaybeAlign(Value)).value(), Value);
41   }
42 }
43 
44 TEST(AlignmentTest, CheckMaybeAlignHasValue) {
45   EXPECT_TRUE(MaybeAlign(1));
46   EXPECT_TRUE(MaybeAlign(1).hasValue());
47   EXPECT_FALSE(MaybeAlign(0));
48   EXPECT_FALSE(MaybeAlign(0).hasValue());
49   EXPECT_FALSE(MaybeAlign());
50   EXPECT_FALSE(MaybeAlign().hasValue());
51 }
52 
53 TEST(AlignmentTest, Division) {
54   for (uint64_t Value : getValidAlignments()) {
55     if (Value > 1) {
56       EXPECT_EQ(Align(Value) / 2, Value / 2);
57       EXPECT_EQ(MaybeAlign(Value) / 2, Value / 2);
58     }
59   }
60   EXPECT_EQ(MaybeAlign(0) / 2, MaybeAlign(0));
61 }
62 
63 TEST(AlignmentTest, AlignTo) {
64   struct {
65     uint64_t alignment;
66     uint64_t offset;
67     uint64_t rounded;
68   } kTests[] = {
69       // MaybeAlign
70       {0, 0, 0},
71       {0, 1, 1},
72       {0, 5, 5},
73       // MaybeAlign / Align
74       {1, 0, 0},
75       {1, 1, 1},
76       {1, 5, 5},
77       {2, 0, 0},
78       {2, 1, 2},
79       {2, 2, 2},
80       {2, 7, 8},
81       {2, 16, 16},
82       {4, 0, 0},
83       {4, 1, 4},
84       {4, 4, 4},
85       {4, 6, 8},
86   };
87   for (const auto &T : kTests) {
88     MaybeAlign A(T.alignment);
89     // Test MaybeAlign
90     EXPECT_EQ(alignTo(T.offset, A), T.rounded);
91     // Test Align
92     if (A) {
93       EXPECT_EQ(alignTo(T.offset, A.getValue()), T.rounded);
94     }
95   }
96 }
97 
98 TEST(AlignmentTest, Log2) {
99   for (uint64_t Value : getValidAlignments()) {
100     EXPECT_EQ(Log2(Align(Value)), Log2_64(Value));
101     EXPECT_EQ(Log2(MaybeAlign(Value)), Log2_64(Value));
102   }
103 }
104 
105 TEST(AlignmentTest, MinAlign) {
106   struct {
107     uint64_t A;
108     uint64_t B;
109     uint64_t MinAlign;
110   } kTests[] = {
111       // MaybeAlign
112       {0, 0, 0},
113       {0, 8, 8},
114       {2, 0, 2},
115       // MaybeAlign / Align
116       {1, 2, 1},
117       {8, 4, 4},
118   };
119   for (const auto &T : kTests) {
120     EXPECT_EQ(commonAlignment(MaybeAlign(T.A), MaybeAlign(T.B)), T.MinAlign);
121     EXPECT_EQ(MinAlign(T.A, T.B), T.MinAlign);
122     if (T.A) {
123       EXPECT_EQ(commonAlignment(Align(T.A), MaybeAlign(T.B)), T.MinAlign);
124     }
125     if (T.B) {
126       EXPECT_EQ(commonAlignment(MaybeAlign(T.A), Align(T.B)), T.MinAlign);
127     }
128     if (T.A && T.B) {
129       EXPECT_EQ(commonAlignment(Align(T.A), Align(T.B)), T.MinAlign);
130     }
131   }
132 }
133 
134 TEST(AlignmentTest, Encode_Decode) {
135   for (uint64_t Value : getValidAlignments()) {
136     {
137       Align Actual(Value);
138       Align Expected = decodeMaybeAlign(encode(Actual)).getValue();
139       EXPECT_EQ(Expected, Actual);
140     }
141     {
142       MaybeAlign Actual(Value);
143       MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
144       EXPECT_EQ(Expected, Actual);
145     }
146   }
147   MaybeAlign Actual(0);
148   MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
149   EXPECT_EQ(Expected, Actual);
150 }
151 
152 TEST(AlignmentTest, isAligned) {
153   struct {
154     uint64_t alignment;
155     uint64_t offset;
156     bool isAligned;
157   } kTests[] = {
158       // MaybeAlign / Align
159       {1, 0, true},  {1, 1, true},  {1, 5, true},  {2, 0, true},
160       {2, 1, false}, {2, 2, true},  {2, 7, false}, {2, 16, true},
161       {4, 0, true},  {4, 1, false}, {4, 4, true},  {4, 6, false},
162   };
163   for (const auto &T : kTests) {
164     MaybeAlign A(T.alignment);
165     // Test MaybeAlign
166     EXPECT_EQ(isAligned(A, T.offset), T.isAligned);
167     // Test Align
168     if (A) {
169       EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned);
170     }
171   }
172 }
173 
174 TEST(AlignmentTest, AlignComparisons) {
175   std::vector<uint64_t> ValidAlignments = getValidAlignments();
176   std::sort(ValidAlignments.begin(), ValidAlignments.end());
177   for (size_t I = 1; I < ValidAlignments.size(); ++I) {
178     assert(I >= 1);
179     const Align A(ValidAlignments[I - 1]);
180     const Align B(ValidAlignments[I]);
181     EXPECT_EQ(A, A);
182     EXPECT_NE(A, B);
183     EXPECT_LT(A, B);
184     EXPECT_GT(B, A);
185     EXPECT_LE(A, B);
186     EXPECT_GE(B, A);
187     EXPECT_LE(A, A);
188     EXPECT_GE(A, A);
189 
190     EXPECT_EQ(A, A.value());
191     EXPECT_NE(A, B.value());
192     EXPECT_LT(A, B.value());
193     EXPECT_GT(B, A.value());
194     EXPECT_LE(A, B.value());
195     EXPECT_GE(B, A.value());
196     EXPECT_LE(A, A.value());
197     EXPECT_GE(A, A.value());
198 
199     EXPECT_EQ(std::max(A, B), B);
200     EXPECT_EQ(std::min(A, B), A);
201 
202     const MaybeAlign MA(ValidAlignments[I - 1]);
203     const MaybeAlign MB(ValidAlignments[I]);
204     EXPECT_EQ(MA, MA);
205     EXPECT_NE(MA, MB);
206     EXPECT_LT(MA, MB);
207     EXPECT_GT(MB, MA);
208     EXPECT_LE(MA, MB);
209     EXPECT_GE(MB, MA);
210     EXPECT_LE(MA, MA);
211     EXPECT_GE(MA, MA);
212 
213     EXPECT_EQ(MA, MA ? (*MA).value() : 0);
214     EXPECT_NE(MA, MB ? (*MB).value() : 0);
215     EXPECT_LT(MA, MB ? (*MB).value() : 0);
216     EXPECT_GT(MB, MA ? (*MA).value() : 0);
217     EXPECT_LE(MA, MB ? (*MB).value() : 0);
218     EXPECT_GE(MB, MA ? (*MA).value() : 0);
219     EXPECT_LE(MA, MA ? (*MA).value() : 0);
220     EXPECT_GE(MA, MA ? (*MA).value() : 0);
221 
222     EXPECT_EQ(std::max(A, B), B);
223     EXPECT_EQ(std::min(A, B), A);
224   }
225 }
226 
227 TEST(AlignmentTest, AssumeAligned) {
228   EXPECT_EQ(assumeAligned(0), Align(1));
229   EXPECT_EQ(assumeAligned(0), Align());
230   EXPECT_EQ(assumeAligned(1), Align(1));
231   EXPECT_EQ(assumeAligned(1), Align());
232 }
233 
234 // Death tests reply on assert which is disabled in release mode.
235 #ifndef NDEBUG
236 
237 // We use a subset of valid alignments for DEATH_TESTs as they are particularly
238 // slow.
239 std::vector<uint64_t> getValidAlignmentsForDeathTest() {
240   return {1, 1ULL << 31, 1ULL << 63};
241 }
242 
243 std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; }
244 
245 TEST(AlignmentDeathTest, Log2) {
246   EXPECT_DEATH(Log2(MaybeAlign(0)), ".* should be defined");
247 }
248 
249 TEST(AlignmentDeathTest, CantConvertUnsetMaybe) {
250   EXPECT_DEATH((MaybeAlign(0).getValue()), ".*");
251 }
252 
253 TEST(AlignmentDeathTest, Division) {
254   EXPECT_DEATH(Align(1) / 2, "Can't halve byte alignment");
255   EXPECT_DEATH(MaybeAlign(1) / 2, "Can't halve byte alignment");
256 
257   EXPECT_DEATH(Align(8) / 0, "Divisor must be positive and a power of 2");
258   EXPECT_DEATH(Align(8) / 3, "Divisor must be positive and a power of 2");
259 }
260 
261 TEST(AlignmentDeathTest, InvalidCTors) {
262   EXPECT_DEATH((Align(0)), "Value must not be 0");
263   for (uint64_t Value : getNonPowerOfTwo()) {
264     EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2");
265     EXPECT_DEATH((MaybeAlign(Value)),
266                  "Alignment is neither 0 nor a power of 2");
267   }
268 }
269 
270 TEST(AlignmentDeathTest, ComparisonsWithZero) {
271   for (uint64_t Value : getValidAlignmentsForDeathTest()) {
272     EXPECT_DEATH((void)(Align(Value) == 0), ".* should be defined");
273     EXPECT_DEATH((void)(Align(Value) != 0), ".* should be defined");
274     EXPECT_DEATH((void)(Align(Value) >= 0), ".* should be defined");
275     EXPECT_DEATH((void)(Align(Value) <= 0), ".* should be defined");
276     EXPECT_DEATH((void)(Align(Value) > 0), ".* should be defined");
277     EXPECT_DEATH((void)(Align(Value) < 0), ".* should be defined");
278   }
279 }
280 
281 TEST(AlignmentDeathTest, CompareMaybeAlignToZero) {
282   for (uint64_t Value : getValidAlignmentsForDeathTest()) {
283     // MaybeAlign is allowed to be == or != 0
284     (void)(MaybeAlign(Value) == 0);
285     (void)(MaybeAlign(Value) != 0);
286     EXPECT_DEATH((void)(MaybeAlign(Value) >= 0), ".* should be defined");
287     EXPECT_DEATH((void)(MaybeAlign(Value) <= 0), ".* should be defined");
288     EXPECT_DEATH((void)(MaybeAlign(Value) > 0), ".* should be defined");
289     EXPECT_DEATH((void)(MaybeAlign(Value) < 0), ".* should be defined");
290   }
291 }
292 
293 TEST(AlignmentDeathTest, CompareAlignToUndefMaybeAlign) {
294   for (uint64_t Value : getValidAlignmentsForDeathTest()) {
295     EXPECT_DEATH((void)(Align(Value) == MaybeAlign(0)), ".* should be defined");
296     EXPECT_DEATH((void)(Align(Value) != MaybeAlign(0)), ".* should be defined");
297     EXPECT_DEATH((void)(Align(Value) >= MaybeAlign(0)), ".* should be defined");
298     EXPECT_DEATH((void)(Align(Value) <= MaybeAlign(0)), ".* should be defined");
299     EXPECT_DEATH((void)(Align(Value) > MaybeAlign(0)), ".* should be defined");
300     EXPECT_DEATH((void)(Align(Value) < MaybeAlign(0)), ".* should be defined");
301   }
302 }
303 
304 #endif // NDEBUG
305 
306 } // end anonymous namespace
307 
308 #ifdef _MSC_VER
309 #pragma warning(pop)
310 #endif
311