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