[LLVM][Alignment] Fix AlignmentTest on platform where size_t != uint64_t

[yroux]

looks good to me, Thanks Guillaume

llvm/unittests/Support/AlignmentTest.cpp

 
 TEST(AlignmentTest, AlignDefaultCTor) { EXPECT_EQ(Align().value(), 1ULL); }
 
 TEST(AlignmentTest, MaybeAlignDefaultCTor) {
   EXPECT_FALSE(MaybeAlign().hasValue());
 }
 
 TEST(AlignmentTest, ValidCTors) {
-  for (size_t Value : getValidAlignments()) {
+  for (uint64_t Value : getValidAlignments()) {
     EXPECT_EQ(Align(Value).value(), Value);
     EXPECT_EQ((*MaybeAlign(Value)).value(), Value);
   }
 }
 
 TEST(AlignmentTest, CheckMaybeAlignHasValue) {
   EXPECT_TRUE(MaybeAlign(1));
   EXPECT_TRUE(MaybeAlign(1).hasValue());
   EXPECT_FALSE(MaybeAlign(0));
   EXPECT_FALSE(MaybeAlign(0).hasValue());
   EXPECT_FALSE(MaybeAlign());
   EXPECT_FALSE(MaybeAlign().hasValue());
 }
 
 TEST(AlignmentTest, Division) {
-  for (size_t Value : getValidAlignments()) {
+  for (uint64_t Value : getValidAlignments()) {
     if (Value > 1) {
       EXPECT_EQ(Align(Value) / 2, Value / 2);
       EXPECT_EQ(MaybeAlign(Value) / 2, Value / 2);
     }
   }
   EXPECT_EQ(MaybeAlign(0) / 2, MaybeAlign(0));
 }
 
for (const auto &T : kTests) {
     EXPECT_EQ(alignTo(T.offset, A), T.rounded);
     // Test Align
     if (A)
       EXPECT_EQ(alignTo(T.offset, A.getValue()), T.rounded);
   }
 }
 
 TEST(AlignmentTest, Log2) {
-  for (size_t Value : getValidAlignments()) {
+  for (uint64_t Value : getValidAlignments()) {
     EXPECT_EQ(Log2(Align(Value)), Log2_64(Value));
     EXPECT_EQ(Log2(MaybeAlign(Value)), Log2_64(Value));
   }
 }
 
 TEST(AlignmentTest, MinAlign) {
   struct {
     uint64_t A;
for (const auto &T : kTests) {
     if (T.B)
       EXPECT_EQ(commonAlignment(MaybeAlign(T.A), Align(T.B)), T.MinAlign);
     if (T.A && T.B)
       EXPECT_EQ(commonAlignment(Align(T.A), Align(T.B)), T.MinAlign);
   }
 }
 
 TEST(AlignmentTest, Encode_Decode) {
-  for (size_t Value : getValidAlignments()) {
+  for (uint64_t Value : getValidAlignments()) {
     {
       Align Actual(Value);
       Align Expected = decodeMaybeAlign(encode(Actual)).getValue();
       EXPECT_EQ(Expected, Actual);
     }
     {
       MaybeAlign Actual(Value);
       MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
TEST(AlignmentDeathTest, Division) {
   EXPECT_DEATH(MaybeAlign(1) / 2, "Can't halve byte alignment");
 
   EXPECT_DEATH(Align(8) / 0, "Divisor must be positive and a power of 2");
   EXPECT_DEATH(Align(8) / 3, "Divisor must be positive and a power of 2");
 }
 
 TEST(AlignmentDeathTest, InvalidCTors) {
   EXPECT_DEATH((Align(0)), "Value must not be 0");
-  for (size_t Value : getNonPowerOfTwo()) {
+  for (uint64_t Value : getNonPowerOfTwo()) {
     EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2");
     EXPECT_DEATH((MaybeAlign(Value)), "Alignment is not 0 or a power of 2");
   }
 }
 
 TEST(AlignmentDeathTest, ComparisonsWithZero) {
-  for (size_t Value : getValidAlignmentsForDeathTest()) {
+  for (uint64_t Value : getValidAlignmentsForDeathTest()) {
     EXPECT_DEATH((void)(Align(Value) == 0), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) != 0), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) >= 0), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) <= 0), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) > 0), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) < 0), ".* should be defined");
   }
 }
 
 TEST(AlignmentDeathTest, CompareMaybeAlignToZero) {
-  for (size_t Value : getValidAlignmentsForDeathTest()) {
+  for (uint64_t Value : getValidAlignmentsForDeathTest()) {
     // MaybeAlign is allowed to be == or != 0
     (void)(MaybeAlign(Value) == 0);
     (void)(MaybeAlign(Value) != 0);
     EXPECT_DEATH((void)(MaybeAlign(Value) >= 0), ".* should be defined");
     EXPECT_DEATH((void)(MaybeAlign(Value) <= 0), ".* should be defined");
     EXPECT_DEATH((void)(MaybeAlign(Value) > 0), ".* should be defined");
     EXPECT_DEATH((void)(MaybeAlign(Value) < 0), ".* should be defined");
   }
 }
 
 TEST(AlignmentDeathTest, CompareAlignToUndefMaybeAlign) {
-  for (size_t Value : getValidAlignmentsForDeathTest()) {
+  for (uint64_t Value : getValidAlignmentsForDeathTest()) {
     EXPECT_DEATH((void)(Align(Value) == MaybeAlign(0)), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) != MaybeAlign(0)), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) >= MaybeAlign(0)), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) <= MaybeAlign(0)), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) > MaybeAlign(0)), ".* should be defined");
     EXPECT_DEATH((void)(Align(Value) < MaybeAlign(0)), ".* should be defined");
   }
 }
 
 #endif // NDEBUG
 
 } // end anonymous namespace