unittests/Support/AlignmentTest.cpp

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