[Align] Remove operations on MaybeAlign that asserted that it had a defined value.

[craig.topper]

Summary

If the caller needs to reponsible for making sure the MaybeAlign
has a value, then we should just make the caller convert it to an Align
with operator*.

I explicitly deleted the relational comparison operators that
were being inherited from Optional. It's unclear what the meaning
of two MaybeAligns were one is defined and the other isn't
should be. So make the caller reponsible for defining the behavior.

I left the ==/!= operators from Optional. But now that exposed a
weird quirk that ==/!= between Align and MaybeAlign required the
MaybeAlign to be defined. But now the Align will be implicitly
converted to MaybeAlign and we'll use the MaybeAlign/MaybeAlign

/!=. I don't think that's a big problem though.

[efriedma]

Optional has template <typename T> bool operator<(const Optional<T> &X, const T &Y); are you sure that doesn't trigger for MaybeAlign/Align?

Otherwise LGTM

[gchatelet]

LGTM thx for the patch.

llvm/include/llvm/IR/DataLayout.h

for (unsigned LegalIntWidth : LegalIntWidths)
         return true;
     return false;
   }
 
   bool isIllegalInteger(uint64_t Width) const { return !isLegalInteger(Width); }
 
   /// Returns true if the given alignment exceeds the natural stack alignment.
   bool exceedsNaturalStackAlignment(Align Alignment) const {
-    return StackNaturalAlign && (Alignment > StackNaturalAlign);
+    return StackNaturalAlign && (Alignment > *StackNaturalAlign);
   }
 
   Align getStackAlignment() const {
     assert(StackNaturalAlign && "StackNaturalAlign must be defined");
     return *StackNaturalAlign;
   }
 
   unsigned getAllocaAddrSpace() const { return AllocaAddrSpace; }

llvm/include/llvm/Support/Alignment.h

 #ifndef NDEBUG
 #include <string>
 #endif // NDEBUG
 
 namespace llvm {
 
 #define ALIGN_CHECK_ISPOSITIVE(decl)                                           \
   assert(decl > 0 && (#decl " should be defined"))
-#define ALIGN_CHECK_ISSET(decl)                                                \
-  assert(decl.hasValue() && (#decl " should be defined"))
 
 /// This struct is a compact representation of a valid (non-zero power of two)
 /// alignment.
 /// It is suitable for use as static global constants.
 struct Align {
 private:
   uint8_t ShiftValue = 0; /// The log2 of the required alignment.
                           /// ShiftValue is less than 64 by construction.
public:
   Align valueOrOne() const { return hasValue() ? getValue() : Align(); }
 };
 
 /// Checks that SizeInBytes is a multiple of the alignment.
 inline bool isAligned(Align Lhs, uint64_t SizeInBytes) {
   return SizeInBytes % Lhs.value() == 0;
 }
 
-/// Checks that SizeInBytes is a multiple of the alignment.
-/// Returns false if the alignment is undefined.
-inline bool isAligned(MaybeAlign Lhs, uint64_t SizeInBytes) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return SizeInBytes % (*Lhs).value() == 0;
-}
-
 /// Checks that Addr is a multiple of the alignment.
 inline bool isAddrAligned(Align Lhs, const void *Addr) {
   return isAligned(Lhs, reinterpret_cast<uintptr_t>(Addr));
 }
 
 /// Returns a multiple of A needed to store `Size` bytes.
 inline uint64_t alignTo(uint64_t Size, Align A) {
   const uint64_t Value = A.value();

 /// bytes, rounding up.
 inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) {
   return offsetToAlignment(reinterpret_cast<uintptr_t>(Addr), Alignment);
 }
 
 /// Returns the log2 of the alignment.
 inline unsigned Log2(Align A) { return A.ShiftValue; }
 
-/// Returns the log2 of the alignment.
-/// \pre A must be defined.
-inline unsigned Log2(MaybeAlign A) {
-  ALIGN_CHECK_ISSET(A);
-  return Log2(A.getValue());
-}
-
 /// Returns the alignment that satisfies both alignments.
 /// Same semantic as MinAlign.
 inline Align commonAlignment(Align A, Align B) { return std::min(A, B); }
 
 /// Returns the alignment that satisfies both alignments.
 /// Same semantic as MinAlign.
 inline Align commonAlignment(Align A, uint64_t Offset) {
   return Align(MinAlign(A.value(), Offset));

 
 /// Comparisons between MaybeAlign and scalars.
 inline bool operator==(MaybeAlign Lhs, uint64_t Rhs) {
   return Lhs ? (*Lhs).value() == Rhs : Rhs == 0;
 }
 inline bool operator!=(MaybeAlign Lhs, uint64_t Rhs) {
   return Lhs ? (*Lhs).value() != Rhs : Rhs != 0;
 }
-inline bool operator<=(MaybeAlign Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return (*Lhs).value() <= Rhs;
-}
-inline bool operator>=(MaybeAlign Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return (*Lhs).value() >= Rhs;
-}
-inline bool operator<(MaybeAlign Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return (*Lhs).value() < Rhs;
-}
-inline bool operator>(MaybeAlign Lhs, uint64_t Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  ALIGN_CHECK_ISPOSITIVE(Rhs);
-  return (*Lhs).value() > Rhs;
-}
 
 /// Comparisons operators between Align.
 inline bool operator==(Align Lhs, Align Rhs) {
   return Lhs.ShiftValue == Rhs.ShiftValue;
 }
 inline bool operator!=(Align Lhs, Align Rhs) {
   return Lhs.ShiftValue != Rhs.ShiftValue;
 }
 inline bool operator<=(Align Lhs, Align Rhs) {
   return Lhs.ShiftValue <= Rhs.ShiftValue;
 }
 inline bool operator>=(Align Lhs, Align Rhs) {
   return Lhs.ShiftValue >= Rhs.ShiftValue;
 }
 inline bool operator<(Align Lhs, Align Rhs) {
   return Lhs.ShiftValue < Rhs.ShiftValue;
 }
 inline bool operator>(Align Lhs, Align Rhs) {
   return Lhs.ShiftValue > Rhs.ShiftValue;
 }
 
-/// Comparisons operators between Align and MaybeAlign.
-inline bool operator==(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() == (*Rhs).value();
-}
-inline bool operator!=(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() != (*Rhs).value();
-}
-inline bool operator<=(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() <= (*Rhs).value();
-}
-inline bool operator>=(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() >= (*Rhs).value();
-}
-inline bool operator<(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() < (*Rhs).value();
-}
-inline bool operator>(Align Lhs, MaybeAlign Rhs) {
-  ALIGN_CHECK_ISSET(Rhs);
-  return Lhs.value() > (*Rhs).value();
-}
-
-/// Comparisons operators between MaybeAlign and Align.
-inline bool operator==(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() == Rhs.value();
-}
-inline bool operator!=(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() != Rhs.value();
-}
-inline bool operator<=(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() <= Rhs.value();
-}
-inline bool operator>=(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() >= Rhs.value();
-}
-inline bool operator<(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() < Rhs.value();
-}
-inline bool operator>(MaybeAlign Lhs, Align Rhs) {
-  ALIGN_CHECK_ISSET(Lhs);
-  return Lhs && (*Lhs).value() > Rhs.value();
-}
+// Don't allow relational comparisons with MaybeAlign.
+bool operator<=(Align Lhs, MaybeAlign Rhs) = delete;
+bool operator>=(Align Lhs, MaybeAlign Rhs) = delete;
+bool operator<(Align Lhs, MaybeAlign Rhs) = delete;
+bool operator>(Align Lhs, MaybeAlign Rhs) = delete;
+
+bool operator<=(MaybeAlign Lhs, Align Rhs) = delete;
+bool operator>=(MaybeAlign Lhs, Align Rhs) = delete;
+bool operator<(MaybeAlign Lhs, Align Rhs) = delete;
+bool operator>(MaybeAlign Lhs, Align Rhs) = delete;
+
+bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
+bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
+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 MaybeAlign operator*(MaybeAlign Lhs, uint64_t Rhs) {
   assert(Rhs > 0 && "Rhs must be positive");

 inline std::string DebugStr(const MaybeAlign &MA) {
   if (MA)
     return std::to_string(MA->value());
   return "None";
 }
 #endif // NDEBUG
 
 #undef ALIGN_CHECK_ISPOSITIVE
-#undef ALIGN_CHECK_ISSET
 
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_ALIGNMENT_H_

llvm/lib/CodeGen/GlobalISel/GISelKnownBits.cpp

void GISelKnownBits::computeKnownBitsForFrameIndex(Register R, KnownBits &Known,
   const MachineInstr &MI = *MRI.getVRegDef(R);
   computeKnownBitsForAlignment(Known, inferPtrAlignment(MI));
 }
 
 void GISelKnownBits::computeKnownBitsForAlignment(KnownBits &Known,
                                                   MaybeAlign Alignment) {
   if (Alignment)
     // The low bits are known zero if the pointer is aligned.
-    Known.Zero.setLowBits(Log2(Alignment));
+    Known.Zero.setLowBits(Log2(*Alignment));
 }
 
 KnownBits GISelKnownBits::getKnownBits(MachineInstr &MI) {
   return getKnownBits(MI.getOperand(0).getReg());
 }
 
 KnownBits GISelKnownBits::getKnownBits(Register R) {
   const LLT Ty = MRI.getType(R);

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitAlloca(const AllocaInst &I) {
   AllocSize = DAG.getNode(ISD::MUL, dl, IntPtr,
                           AllocSize,
                           DAG.getConstant(TySize, dl, IntPtr));
 
   // Handle alignment.  If the requested alignment is less than or equal to
   // the stack alignment, ignore it.  If the size is greater than or equal to
   // the stack alignment, we note this in the DYNAMIC_STACKALLOC node.
   Align StackAlign = DAG.getSubtarget().getFrameLowering()->getStackAlign();
-  if (Alignment <= StackAlign)
+  if (*Alignment <= StackAlign)
     Alignment = None;
 
   const uint64_t StackAlignMask = StackAlign.value() - 1U;
   // Round the size of the allocation up to the stack alignment size
   // by add SA-1 to the size. This doesn't overflow because we're computing
   // an address inside an alloca.
   SDNodeFlags Flags;
   Flags.setNoUnsignedWrap(true);

llvm/lib/IR/Globals.cpp

 }
 
 unsigned GlobalValue::getAddressSpace() const {
   PointerType *PtrTy = getType();
   return PtrTy->getAddressSpace();
 }
 
 void GlobalObject::setAlignment(MaybeAlign Align) {
-  assert((!Align || Align <= MaximumAlignment) &&
+  assert((!Align || *Align <= MaximumAlignment) &&
          "Alignment is greater than MaximumAlignment!");
   unsigned AlignmentData = encode(Align);
   unsigned OldData = getGlobalValueSubClassData();
   setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
   assert(MaybeAlign(getAlignment()) == Align &&
          "Alignment representation error!");
 }
 

llvm/lib/LTO/LTO.cpp

for (const InputFile::Symbol &Sym : Syms) {
     // Common resolution: collect the maximum size/alignment over all commons.
     // We also record if we see an instance of a common as prevailing, so that
     // if none is prevailing we can ignore it later.
     if (Sym.isCommon()) {
       // FIXME: We should figure out what to do about commons defined by asm.
       // For now they aren't reported correctly by ModuleSymbolTable.
       auto &CommonRes = RegularLTO.Commons[std::string(Sym.getIRName())];
       CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
-      CommonRes.Align =
-          std::max(CommonRes.Align, MaybeAlign(Sym.getCommonAlignment()));
+      MaybeAlign SymAlign(Sym.getCommonAlignment());
+      if (SymAlign)
+        CommonRes.Align = max(*SymAlign, CommonRes.Align);
       CommonRes.Prevailing |= Res.Prevailing;
     }
 
   }
   if (!M.getComdatSymbolTable().empty())
     for (GlobalValue &GV : M.global_values())
       handleNonPrevailingComdat(GV, NonPrevailingComdats);
   assert(MsymI == MsymE);

llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp

if (auto *VecTy = dyn_cast<FixedVectorType>(DataTy)) {
 
     // We don't support extending fp types.
      unsigned VecWidth = DataTy->getPrimitiveSizeInBits();
     if (VecWidth != 128 && VecTy->getElementType()->isFloatingPointTy())
       return false;
   }
 
   unsigned EltWidth = DataTy->getScalarSizeInBits();
-  return (EltWidth == 32 && (!Alignment || Alignment >= 4)) ||
-         (EltWidth == 16 && (!Alignment || Alignment >= 2)) ||
+  return (EltWidth == 32 && (!Alignment || *Alignment >= 4)) ||
+         (EltWidth == 16 && (!Alignment || *Alignment >= 2)) ||
          (EltWidth == 8);
 }
 
 bool ARMTTIImpl::isLegalMaskedGather(Type *Ty, MaybeAlign Alignment) {
   if (!EnableMaskedGatherScatters || !ST->hasMVEIntegerOps())
     return false;
 
   // This method is called in 2 places:
   //  - from the vectorizer with a scalar type, in which case we need to get
   //  this as good as we can with the limited info we have (and rely on the cost
   //  model for the rest).
   //  - from the masked intrinsic lowering pass with the actual vector type.
   // For MVE, we have a custom lowering pass that will already have custom
   // legalised any gathers that we can to MVE intrinsics, and want to expand all
   // the rest. The pass runs before the masked intrinsic lowering pass, so if we
   // are here, we know we want to expand.
   if (isa<VectorType>(Ty))
     return false;
 
   unsigned EltWidth = Ty->getScalarSizeInBits();
-  return ((EltWidth == 32 && (!Alignment || Alignment >= 4)) ||
-          (EltWidth == 16 && (!Alignment || Alignment >= 2)) || EltWidth == 8);
+  return ((EltWidth == 32 && (!Alignment || *Alignment >= 4)) ||
+          (EltWidth == 16 && (!Alignment || *Alignment >= 2)) || EltWidth == 8);
 }
 
 int ARMTTIImpl::getMemcpyCost(const Instruction *I) {
   const MemCpyInst *MI = dyn_cast<MemCpyInst>(I);
   assert(MI && "MemcpyInst expected");
   ConstantInt *C = dyn_cast<ConstantInt>(MI->getLength());
 
   // To model the cost of a library call, we assume 1 for the call, and

llvm/lib/Target/PowerPC/PPCTargetTransformInfo.cpp

int PPCTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
   // explicitly check this case.
   unsigned MemBytes = Src->getPrimitiveSizeInBits();
   if (Opcode == Instruction::Load && ST->hasVSX() && IsAltivecType &&
       (MemBytes == 64 || (ST->hasP8Vector() && MemBytes == 32)))
     return 1;
 
   // Aligned loads and stores are easy.
   unsigned SrcBytes = LT.second.getStoreSize();
-  if (!SrcBytes || !Alignment || Alignment >= SrcBytes)
+  if (!SrcBytes || !Alignment || *Alignment >= SrcBytes)
     return Cost;
 
   // If we can use the permutation-based load sequence, then this is also
   // relatively cheap (not counting loop-invariant instructions): one load plus
   // one permute (the last load in a series has extra cost, but we're
   // neglecting that here). Note that on the P7, we could do unaligned loads
   // for Altivec types using the VSX instructions, but that's more expensive
   // than using the permutation-based load sequence. On the P8, that's no
   // longer true.
   if (Opcode == Instruction::Load &&
       ((!ST->hasP8Vector() && IsAltivecType) || IsQPXType) &&
-      Alignment >= LT.second.getScalarType().getStoreSize())
+      *Alignment >= LT.second.getScalarType().getStoreSize())
     return Cost + LT.first; // Add the cost of the permutations.
 
   // For VSX, we can do unaligned loads and stores on Altivec/VSX types. On the
   // P7, unaligned vector loads are more expensive than the permutation-based
   // load sequence, so that might be used instead, but regardless, the net cost
   // is about the same (not counting loop-invariant instructions).
   if (IsVSXType || (ST->hasVSX() && IsAltivecType))
     return Cost;

llvm/lib/Target/X86/X86ISelLowering.cpp

if (LoadSDNode *LD = dyn_cast<LoadSDNode>(SrcOp)) {
     }
 
     // FIXME: 256-bit vector instructions don't require a strict alignment,
     // improve this code to support it better.
     Align RequiredAlign(VT.getSizeInBits() / 8);
     SDValue Chain = LD->getChain();
     // Make sure the stack object alignment is at least 16 or 32.
     MachineFrameInfo &MFI = DAG.getMachineFunction().getFrameInfo();
-    if (DAG.InferPtrAlign(Ptr) < RequiredAlign) {
+    MaybeAlign InferredAlign = DAG.InferPtrAlign(Ptr);
+    if (!InferredAlign || *InferredAlign < RequiredAlign) {
       if (MFI.isFixedObjectIndex(FI)) {
         // Can't change the alignment. FIXME: It's possible to compute
         // the exact stack offset and reference FI + adjust offset instead.
         // If someone *really* cares about this. That's the way to implement it.
         return SDValue();
       } else {
         MFI.setObjectAlignment(FI, RequiredAlign);
       }
if (hasInlineStackProbe(MF)) {
       Chain = DAG.getCopyToReg(Chain, dl, Vreg, Size);
       Result = DAG.getNode(X86ISD::PROBED_ALLOCA, dl, SPTy, Chain,
                            DAG.getRegister(Vreg, SPTy));
     } else {
       SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
       Chain = SP.getValue(1);
       Result = DAG.getNode(ISD::SUB, dl, VT, SP, Size); // Value
     }
-    if (Alignment && Alignment > StackAlign)
+    if (Alignment && *Alignment > StackAlign)
       Result =
           DAG.getNode(ISD::AND, dl, VT, Result,
                       DAG.getConstant(~(Alignment->value() - 1ULL), dl, VT));
     Chain = DAG.getCopyToReg(Chain, dl, SPReg, Result); // Output chain
   } else if (SplitStack) {
     MachineRegisterInfo &MRI = MF.getRegInfo();
 
     if (Is64Bit) {

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

static unsigned getKnownAlignForUse(Attributor &A,
   if (auto *SI = dyn_cast<StoreInst>(I)) {
     if (SI->getPointerOperand() == UseV)
       MA = SI->getAlign();
   } else if (auto *LI = dyn_cast<LoadInst>(I)) {
     if (LI->getPointerOperand() == UseV)
       MA = LI->getAlign();
   }
 
-  if (!MA.hasValue() || MA <= 1)
+  if (!MA || *MA <= 1)
     return 0;
 
   unsigned Alignment = MA->value();
   int64_t Offset;
 
   if (const Value *Base = GetPointerBaseWithConstantOffset(UseV, Offset, DL)) {
     if (Base == &AssociatedValue) {
       // BasePointerAddr + Offset = Alignment * Q for some integer Q.

llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp

bool MemCpyOptPass::processByValArgument(CallBase &CB, unsigned ArgNo) {
   // then it is some target specific value that we can't know.
   MaybeAlign ByValAlign = CB.getParamAlign(ArgNo);
   if (!ByValAlign) return false;
 
   // If it is greater than the memcpy, then we check to see if we can force the
   // source of the memcpy to the alignment we need.  If we fail, we bail out.
   AssumptionCache &AC = LookupAssumptionCache();
   DominatorTree &DT = LookupDomTree();
-  if (MDep->getSourceAlign() < ByValAlign &&
+  MaybeAlign MemDepAlign = MDep->getSourceAlign();
+  if ((!MemDepAlign || *MemDepAlign < *ByValAlign) &&
       getOrEnforceKnownAlignment(MDep->getSource(), ByValAlign, DL, &CB, &AC,
-                                 &DT) < ByValAlign)
+                                 &DT) < *ByValAlign)
     return false;
 
   // The address space of the memcpy source must match the byval argument
   if (MDep->getSource()->getType()->getPointerAddressSpace() !=
       ByValArg->getType()->getPointerAddressSpace())
     return false;
 
   // Verify that the copied-from memory doesn't change in between the memcpy and

llvm/unittests/Support/AlignmentTest.cpp

TEST(AlignmentTest, AlignToWithSkew) {
   EXPECT_EQ(alignTo(5, Align(8), 7), 7U);
   EXPECT_EQ(alignTo(17, Align(8), 1), 17U);
   EXPECT_EQ(alignTo(~0LL, Align(8), 3), 3U);
 }
 
 TEST(AlignmentTest, Log2) {
   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;
     uint64_t B;
     uint64_t MinAlign;
struct {
     }
   } kTests[] = {
       {1, 0, true},  {1, 1, true},  {1, 5, true},  {2, 0, true},
       {2, 1, false}, {2, 2, true},  {2, 7, false}, {2, 16, true},
       {4, 0, true},  {4, 1, false}, {4, 4, true},  {4, 6, false},
   };
   for (const auto &T : kTests) {
     MaybeAlign A(T.alignment);
-    // Test MaybeAlign
-    EXPECT_EQ(isAligned(A, T.offset), T.isAligned);
     // Test Align
     if (A) {
       EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned);
       EXPECT_EQ(isAddrAligned(A.getValue(), T.forgedAddr()), T.isAligned);
     }
   }
 }
 
for (size_t I = 1; I < ValidAlignments.size(); ++I) {
 
     EXPECT_EQ(std::max(A, B), B);
     EXPECT_EQ(std::min(A, B), A);
 
     const MaybeAlign MA(ValidAlignments[I - 1]);
     const MaybeAlign MB(ValidAlignments[I]);
     EXPECT_EQ(MA, MA);
     EXPECT_NE(MA, MB);
-    EXPECT_LT(MA, MB);
-    EXPECT_GT(MB, MA);
-    EXPECT_LE(MA, MB);
-    EXPECT_GE(MB, MA);
-    EXPECT_LE(MA, MA);
-    EXPECT_GE(MA, MA);
 
     EXPECT_EQ(MA, MA ? (*MA).value() : 0);
     EXPECT_NE(MA, MB ? (*MB).value() : 0);
-    EXPECT_LT(MA, MB ? (*MB).value() : 0);
-    EXPECT_GT(MB, MA ? (*MA).value() : 0);
-    EXPECT_LE(MA, MB ? (*MB).value() : 0);
-    EXPECT_GE(MB, MA ? (*MA).value() : 0);
-    EXPECT_LE(MA, MA ? (*MA).value() : 0);
-    EXPECT_GE(MA, MA ? (*MA).value() : 0);
 
     EXPECT_EQ(std::max(A, B), B);
     EXPECT_EQ(std::min(A, B), A);
   }
 }
 
 TEST(AlignmentTest, Max) {
   // We introduce std::max here to test ADL.
TEST(AlignmentTest, Max) {
   EXPECT_EQ(max(MaybeAlign(2), Align(2)), Align(2));
   EXPECT_EQ(max(Align(2), MaybeAlign(2)), Align(2));
 
   EXPECT_EQ(max(MaybeAlign(4), Align(2)), Align(4));
   EXPECT_EQ(max(Align(2), MaybeAlign(4)), Align(4));
 
   // Uses std::max.
   EXPECT_EQ(max(Align(2), Align(4)), Align(4));
-  EXPECT_EQ(max(MaybeAlign(2), MaybeAlign(4)), MaybeAlign(4));
-  EXPECT_EQ(max(MaybeAlign(), MaybeAlign()), MaybeAlign());
 }
 
 TEST(AlignmentTest, AssumeAligned) {
   EXPECT_EQ(assumeAligned(0), Align(1));
   EXPECT_EQ(assumeAligned(0), Align());
   EXPECT_EQ(assumeAligned(1), Align(1));
   EXPECT_EQ(assumeAligned(1), Align());
 }
 
 // Death tests reply on assert which is disabled in release mode.
 #ifndef NDEBUG
 
 // We use a subset of valid alignments for DEATH_TESTs as they are particularly
 // slow.
 std::vector<uint64_t> getValidAlignmentsForDeathTest() {
   return {1, 1ULL << 31, 1ULL << 63};
 }
 
 std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; }
 
-TEST(AlignmentDeathTest, Log2) {
-  EXPECT_DEATH(Log2(MaybeAlign(0)), ".* should be defined");
-}
-
 TEST(AlignmentDeathTest, CantConvertUnsetMaybe) {
   EXPECT_DEATH((MaybeAlign(0).getValue()), ".*");
 }
 
 TEST(AlignmentDeathTest, Division) {
   EXPECT_DEATH(Align(1) / 2, "Can't halve byte alignment");
   EXPECT_DEATH(MaybeAlign(1) / 2, "Can't halve byte alignment");
 
TEST(AlignmentDeathTest, ComparisonsWithZero) {
   }
 }
 
 TEST(AlignmentDeathTest, CompareMaybeAlignToZero) {
   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 (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");
   }
 }
 
 TEST(AlignmentDeathTest, AlignAddr) {
   const void *const unaligned_high_ptr =
       reinterpret_cast<const void *>(std::numeric_limits<uintptr_t>::max() - 1);
   EXPECT_DEATH(alignAddr(unaligned_high_ptr, Align(16)), "Overflow");
 }
 
 #endif // NDEBUG
 
 } // end anonymous namespace
 
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif