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(8), 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 EXPECT_EQ(Align::None().value(), 1ULL); 56 } 57 58 TEST(AlignmentTest, MaybeAlignDefaultCTor) { 59 EXPECT_FALSE(MaybeAlign().hasValue()); 60 } 61 62 TEST(AlignmentTest, ValidCTors) { 63 for (uint64_t Value : getValidAlignments()) { 64 EXPECT_EQ(Align(Value).value(), Value); 65 EXPECT_EQ((*MaybeAlign(Value)).value(), Value); 66 } 67 } 68 69 TEST(AlignmentTest, CheckMaybeAlignHasValue) { 70 EXPECT_TRUE(MaybeAlign(1)); 71 EXPECT_TRUE(MaybeAlign(1).hasValue()); 72 EXPECT_FALSE(MaybeAlign(0)); 73 EXPECT_FALSE(MaybeAlign(0).hasValue()); 74 EXPECT_FALSE(MaybeAlign()); 75 EXPECT_FALSE(MaybeAlign().hasValue()); 76 } 77 78 TEST(AlignmentTest, Division) { 79 for (uint64_t Value : getValidAlignments()) { 80 if (Value > 1) { 81 EXPECT_EQ(Align(Value) / 2, Value / 2); 82 EXPECT_EQ(MaybeAlign(Value) / 2, Value / 2); 83 } 84 } 85 EXPECT_EQ(MaybeAlign(0) / 2, MaybeAlign(0)); 86 } 87 88 TEST(AlignmentTest, AlignTo) { 89 struct { 90 uint64_t alignment; 91 uint64_t offset; 92 uint64_t rounded; 93 } kTests[] = { 94 // MaybeAlign 95 {0, 0, 0}, 96 {0, 1, 1}, 97 {0, 5, 5}, 98 // MaybeAlign / Align 99 {1, 0, 0}, 100 {1, 1, 1}, 101 {1, 5, 5}, 102 {2, 0, 0}, 103 {2, 1, 2}, 104 {2, 2, 2}, 105 {2, 7, 8}, 106 {2, 16, 16}, 107 {4, 0, 0}, 108 {4, 1, 4}, 109 {4, 4, 4}, 110 {4, 6, 8}, 111 }; 112 for (const auto &T : kTests) { 113 MaybeAlign A(T.alignment); 114 // Test MaybeAlign 115 EXPECT_EQ(alignTo(T.offset, A), T.rounded); 116 // Test Align 117 if (A) { 118 EXPECT_EQ(alignTo(T.offset, A.getValue()), T.rounded); 119 } 120 } 121 } 122 123 TEST(AlignmentTest, Log2) { 124 for (uint64_t Value : getValidAlignments()) { 125 EXPECT_EQ(Log2(Align(Value)), Log2_64(Value)); 126 EXPECT_EQ(Log2(MaybeAlign(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) { 178 struct { 179 uint64_t alignment; 180 uint64_t offset; 181 bool isAligned; 182 } kTests[] = { 183 // MaybeAlign / Align 184 {1, 0, true}, {1, 1, true}, {1, 5, true}, {2, 0, true}, 185 {2, 1, false}, {2, 2, true}, {2, 7, false}, {2, 16, true}, 186 {4, 0, true}, {4, 1, false}, {4, 4, true}, {4, 6, false}, 187 }; 188 for (const auto &T : kTests) { 189 MaybeAlign A(T.alignment); 190 // Test MaybeAlign 191 EXPECT_EQ(isAligned(A, T.offset), T.isAligned); 192 // Test Align 193 if (A) { 194 EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned); 195 } 196 } 197 } 198 199 TEST(AlignmentTest, AlignComparisons) { 200 std::vector<uint64_t> ValidAlignments = getValidAlignments(); 201 std::sort(ValidAlignments.begin(), ValidAlignments.end()); 202 for (size_t I = 1; I < ValidAlignments.size(); ++I) { 203 assert(I >= 1); 204 const Align A(ValidAlignments[I - 1]); 205 const Align B(ValidAlignments[I]); 206 EXPECT_EQ(A, A); 207 EXPECT_NE(A, B); 208 EXPECT_LT(A, B); 209 EXPECT_GT(B, A); 210 EXPECT_LE(A, B); 211 EXPECT_GE(B, A); 212 EXPECT_LE(A, A); 213 EXPECT_GE(A, A); 214 215 EXPECT_EQ(A, A.value()); 216 EXPECT_NE(A, B.value()); 217 EXPECT_LT(A, B.value()); 218 EXPECT_GT(B, A.value()); 219 EXPECT_LE(A, B.value()); 220 EXPECT_GE(B, A.value()); 221 EXPECT_LE(A, A.value()); 222 EXPECT_GE(A, A.value()); 223 224 EXPECT_EQ(std::max(A, B), B); 225 EXPECT_EQ(std::min(A, B), A); 226 227 const MaybeAlign MA(ValidAlignments[I - 1]); 228 const MaybeAlign MB(ValidAlignments[I]); 229 EXPECT_EQ(MA, MA); 230 EXPECT_NE(MA, MB); 231 EXPECT_LT(MA, MB); 232 EXPECT_GT(MB, MA); 233 EXPECT_LE(MA, MB); 234 EXPECT_GE(MB, MA); 235 EXPECT_LE(MA, MA); 236 EXPECT_GE(MA, MA); 237 238 EXPECT_EQ(MA, MA ? (*MA).value() : 0); 239 EXPECT_NE(MA, MB ? (*MB).value() : 0); 240 EXPECT_LT(MA, MB ? (*MB).value() : 0); 241 EXPECT_GT(MB, MA ? (*MA).value() : 0); 242 EXPECT_LE(MA, MB ? (*MB).value() : 0); 243 EXPECT_GE(MB, MA ? (*MA).value() : 0); 244 EXPECT_LE(MA, MA ? (*MA).value() : 0); 245 EXPECT_GE(MA, MA ? (*MA).value() : 0); 246 247 EXPECT_EQ(std::max(A, B), B); 248 EXPECT_EQ(std::min(A, B), A); 249 } 250 } 251 252 TEST(AlignmentTest, Max) { 253 // We introduce std::max here to test ADL. 254 using std::max; 255 256 // Uses llvm::max. 257 EXPECT_EQ(max(MaybeAlign(), Align(2)), Align(2)); 258 EXPECT_EQ(max(Align(2), MaybeAlign()), Align(2)); 259 260 EXPECT_EQ(max(MaybeAlign(1), Align(2)), Align(2)); 261 EXPECT_EQ(max(Align(2), MaybeAlign(1)), Align(2)); 262 263 EXPECT_EQ(max(MaybeAlign(2), Align(2)), Align(2)); 264 EXPECT_EQ(max(Align(2), MaybeAlign(2)), Align(2)); 265 266 EXPECT_EQ(max(MaybeAlign(4), Align(2)), Align(4)); 267 EXPECT_EQ(max(Align(2), MaybeAlign(4)), Align(4)); 268 269 // Uses std::max. 270 EXPECT_EQ(max(Align(2), Align(4)), Align(4)); 271 EXPECT_EQ(max(MaybeAlign(2), MaybeAlign(4)), MaybeAlign(4)); 272 EXPECT_EQ(max(MaybeAlign(), MaybeAlign()), MaybeAlign()); 273 } 274 275 TEST(AlignmentTest, AssumeAligned) { 276 EXPECT_EQ(assumeAligned(0), Align(1)); 277 EXPECT_EQ(assumeAligned(0), Align()); 278 EXPECT_EQ(assumeAligned(1), Align(1)); 279 EXPECT_EQ(assumeAligned(1), Align()); 280 } 281 282 // Death tests reply on assert which is disabled in release mode. 283 #ifndef NDEBUG 284 285 // We use a subset of valid alignments for DEATH_TESTs as they are particularly 286 // slow. 287 std::vector<uint64_t> getValidAlignmentsForDeathTest() { 288 return {1, 1ULL << 31, 1ULL << 63}; 289 } 290 291 std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; } 292 293 TEST(AlignmentDeathTest, Log2) { 294 EXPECT_DEATH(Log2(MaybeAlign(0)), ".* should be defined"); 295 } 296 297 TEST(AlignmentDeathTest, CantConvertUnsetMaybe) { 298 EXPECT_DEATH((MaybeAlign(0).getValue()), ".*"); 299 } 300 301 TEST(AlignmentDeathTest, Division) { 302 EXPECT_DEATH(Align(1) / 2, "Can't halve byte alignment"); 303 EXPECT_DEATH(MaybeAlign(1) / 2, "Can't halve byte alignment"); 304 305 EXPECT_DEATH(Align(8) / 0, "Divisor must be positive and a power of 2"); 306 EXPECT_DEATH(Align(8) / 3, "Divisor must be positive and a power of 2"); 307 } 308 309 TEST(AlignmentDeathTest, InvalidCTors) { 310 EXPECT_DEATH((Align(0)), "Value must not be 0"); 311 for (uint64_t Value : getNonPowerOfTwo()) { 312 EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2"); 313 EXPECT_DEATH((MaybeAlign(Value)), 314 "Alignment is neither 0 nor a power of 2"); 315 } 316 } 317 318 TEST(AlignmentDeathTest, ComparisonsWithZero) { 319 for (uint64_t Value : getValidAlignmentsForDeathTest()) { 320 EXPECT_DEATH((void)(Align(Value) == 0), ".* should be defined"); 321 EXPECT_DEATH((void)(Align(Value) != 0), ".* should be defined"); 322 EXPECT_DEATH((void)(Align(Value) >= 0), ".* should be defined"); 323 EXPECT_DEATH((void)(Align(Value) <= 0), ".* should be defined"); 324 EXPECT_DEATH((void)(Align(Value) > 0), ".* should be defined"); 325 EXPECT_DEATH((void)(Align(Value) < 0), ".* should be defined"); 326 } 327 } 328 329 TEST(AlignmentDeathTest, CompareMaybeAlignToZero) { 330 for (uint64_t Value : getValidAlignmentsForDeathTest()) { 331 // MaybeAlign is allowed to be == or != 0 332 (void)(MaybeAlign(Value) == 0); 333 (void)(MaybeAlign(Value) != 0); 334 EXPECT_DEATH((void)(MaybeAlign(Value) >= 0), ".* should be defined"); 335 EXPECT_DEATH((void)(MaybeAlign(Value) <= 0), ".* should be defined"); 336 EXPECT_DEATH((void)(MaybeAlign(Value) > 0), ".* should be defined"); 337 EXPECT_DEATH((void)(MaybeAlign(Value) < 0), ".* should be defined"); 338 } 339 } 340 341 TEST(AlignmentDeathTest, CompareAlignToUndefMaybeAlign) { 342 for (uint64_t Value : getValidAlignmentsForDeathTest()) { 343 EXPECT_DEATH((void)(Align(Value) == MaybeAlign(0)), ".* should be defined"); 344 EXPECT_DEATH((void)(Align(Value) != MaybeAlign(0)), ".* should be defined"); 345 EXPECT_DEATH((void)(Align(Value) >= MaybeAlign(0)), ".* should be defined"); 346 EXPECT_DEATH((void)(Align(Value) <= MaybeAlign(0)), ".* should be defined"); 347 EXPECT_DEATH((void)(Align(Value) > MaybeAlign(0)), ".* should be defined"); 348 EXPECT_DEATH((void)(Align(Value) < MaybeAlign(0)), ".* should be defined"); 349 } 350 } 351 352 #endif // NDEBUG 353 354 } // end anonymous namespace 355 356 #ifdef _MSC_VER 357 #pragma warning(pop) 358 #endif 359