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