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