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