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