[Alignment] Use 'previous()' method instead of scalar division

[gchatelet]

Summary

This is in preparation of integration with D128052.

[tschuett]

llvm/include/llvm/Support/Alignment.h

87

Alignment without the a.

88

Please remove the auto.

[gchatelet]

• Address comments

[gchatelet]

Thx for the review @tschuett

llvm/include/llvm/Support/Alignment.h

explicit Align(uint64_t Value) {
     ShiftValue = Log2_64(Value);
     assert(ShiftValue < 64 && "Broken invariant");
   }
 
   /// This is a hole in the type system and should not be abused.
   /// Needed to interact with C for instance.
   uint64_t value() const { return uint64_t(1) << ShiftValue; }
 
+  // Returns the previous aAlignment.
+  auto previous() const {
+    assert(ShiftValue != 0 && "Undefined operation");
+    Align Out;
+    Out.ShiftValue = ShiftValue - 1;
+    return Out;
+  }
+
   /// Allow constructions of constexpr Align.
   template <size_t kValue> constexpr static LogValue Constant() {
     return LogValue{static_cast<uint8_t>(CTLog2<kValue>())};
   }
 
   /// Allow constructions of constexpr Align from types.
   /// Compile time equivalent to Align(alignof(T)).
   template <typename T> constexpr static LogValue Of() {

 bool operator<(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
 bool operator>(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
 
 inline Align operator*(Align Lhs, uint64_t Rhs) {
   assert(Rhs > 0 && "Rhs must be positive");
   return Align(Lhs.value() * Rhs);
 }
 
-inline Align operator/(Align Lhs, uint64_t Divisor) {
-  assert(llvm::isPowerOf2_64(Divisor) &&
-         "Divisor must be positive and a power of 2");
-  assert(Lhs != 1 && "Can't halve byte alignment");
-  return Align(Lhs.value() / Divisor);
-}
-
 #ifndef NDEBUG
 // For usage in LLVM_DEBUG macros.
 inline std::string DebugStr(const Align &A) {
   return std::to_string(A.value());
 }
 // For usage in LLVM_DEBUG macros.
 inline std::string DebugStr(const MaybeAlign &MA) {
   if (MA)

llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp

if (DstAlignCanChange) {
     Type *IRTy = getTypeForLLT(MemOps[0], C);
     Align NewAlign = DL.getABITypeAlign(IRTy);
 
     // Don't promote to an alignment that would require dynamic stack
     // realignment.
     const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
     if (!TRI->hasStackRealignment(MF))
       while (NewAlign > Alignment && DL.exceedsNaturalStackAlignment(NewAlign))
-        NewAlign = NewAlign / 2;
+        NewAlign = NewAlign.previous();
 
     if (NewAlign > Alignment) {
       Alignment = NewAlign;
       unsigned FI = FIDef->getOperand(1).getIndex();
       // Give the stack frame object a larger alignment if needed.
       if (MFI.getObjectAlign(FI) < Alignment)
         MFI.setObjectAlignment(FI, Alignment);
     }
if (DstAlignCanChange) {
     Type *IRTy = getTypeForLLT(MemOps[0], C);
     Align NewAlign = DL.getABITypeAlign(IRTy);
 
     // Don't promote to an alignment that would require dynamic stack
     // realignment.
     const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
     if (!TRI->hasStackRealignment(MF))
       while (NewAlign > Alignment && DL.exceedsNaturalStackAlignment(NewAlign))
-        NewAlign = NewAlign / 2;
+        NewAlign = NewAlign.previous();
 
     if (NewAlign > Alignment) {
       Alignment = NewAlign;
       unsigned FI = FIDef->getOperand(1).getIndex();
       // Give the stack frame object a larger alignment if needed.
       if (MFI.getObjectAlign(FI) < Alignment)
         MFI.setObjectAlignment(FI, Alignment);
     }

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

if (DstAlignCanChange) {
     Type *Ty = MemOps[0].getTypeForEVT(C);
     Align NewAlign = DL.getABITypeAlign(Ty);
 
     // Don't promote to an alignment that would require dynamic stack
     // realignment.
     const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
     if (!TRI->hasStackRealignment(MF))
       while (NewAlign > Alignment && DL.exceedsNaturalStackAlignment(NewAlign))
-        NewAlign = NewAlign / 2;
+        NewAlign = NewAlign.previous();
 
     if (NewAlign > Alignment) {
       // Give the stack frame object a larger alignment if needed.
       if (MFI.getObjectAlign(FI->getIndex()) < NewAlign)
         MFI.setObjectAlignment(FI->getIndex(), NewAlign);
       Alignment = NewAlign;
     }
   }

llvm/unittests/Support/AlignmentTest.cpp

TEST(AlignmentTest, CheckMaybeAlignHasValue) {
   EXPECT_FALSE(MaybeAlign(0).hasValue());
   EXPECT_FALSE(MaybeAlign());
   EXPECT_FALSE(MaybeAlign().hasValue());
 }
 
 TEST(AlignmentTest, Division) {
   for (uint64_t Value : getValidAlignments()) {
     if (Value > 1) {
-      EXPECT_EQ(Align(Value) / 2, Value / 2);
+      EXPECT_EQ(Align(Value).previous(), Value / 2);
     }
   }
 }
 
 TEST(AlignmentTest, AlignTo) {
   struct {
     uint64_t alignment;
     uint64_t offset;

 }
 
 std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; }
 
 TEST(AlignmentDeathTest, CantConvertUnsetMaybe) {
   EXPECT_DEATH((MaybeAlign(0).getValue()), ".*");
 }
 
-TEST(AlignmentDeathTest, Division) {
-  EXPECT_DEATH(Align(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 (uint64_t Value : getNonPowerOfTwo()) {
     EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2");
     EXPECT_DEATH((MaybeAlign(Value)),
                  "Alignment is neither 0 nor a power of 2");
   }
 }