diff --git a/llvm/include/llvm/Support/Alignment.h b/llvm/include/llvm/Support/Alignment.h
new file mode 100644
--- /dev/null
+++ b/llvm/include/llvm/Support/Alignment.h
@@ -0,0 +1,415 @@
+//===-- llvm/Support/Alignment.h - Useful alignment functions ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains types to represent alignments.
+// They are instrumented to guarantee some invariants are preserved and prevent
+// invalid manipulations.
+//
+// - Align represents an alignment in bytes, it is always set and always a valid
+// power of two, its minimum value is 1 which means no alignment requirements.
+//
+// - MaybeAlign is an optional type, it may be undefined or set. When it's set
+// you can get the underlying Align type by using the getValue() method.
+//
+// Before the alignments were represented as `unsigned` with 0 meaning
+// `undefined alignment requirements` and 1 meaning `no alignment requirements`,
+// this caused hard to spot bugs:
+//
+// * Unclear semantic when comparing alignments:
+//     unsigned AlignmentA = GetA();
+//     unsigned AlignmentB = GetB();
+//     if (AlignmentA <= AlignmentB) {
+//        // Unclear what this means if AlignmentA or AlignmentB are allowed to
+//        // be zero.
+//     }
+// * Mistakenly passing a `bool` as an alignment in a function call because of
+//   integral type promotion.
+// * Passing -1 as an alignment.
+// * Convoluted bit masking / shifting / arithmetic using `unsigned` with poor
+//   guarantees on the final value correctness.
+// * Semantic slippage when halving alignment:
+//     unsigned Align = GetAlignment();
+//     unsigned HalfAlign = Align / 2; // If Align is 1, HalfAlign is undefined
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_ALIGNMENT_H_
+#define LLVM_SUPPORT_ALIGNMENT_H_
+
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/MathExtras.h"
+#include <cassert>
+#include <limits>
+
+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 final {
+private:
+  uint8_t ShiftValue; // The log2 of the required alignment.
+  friend struct MaybeAlign;
+  friend unsigned Log2(Align);
+  friend bool operator==(Align Lhs, Align Rhs);
+  friend bool operator!=(Align Lhs, Align Rhs);
+  friend bool operator<=(Align Lhs, Align Rhs);
+  friend bool operator>=(Align Lhs, Align Rhs);
+  friend bool operator<(Align Lhs, Align Rhs);
+  friend bool operator>(Align Lhs, Align Rhs);
+
+public:
+  // Default is byte-aligned.
+  Align() : ShiftValue(0) {}
+  // Do not perform checks in case of copy/move construct/assign, because the
+  // checks have been performed when building `Other`.
+  Align(const Align &Other) = default;
+  Align &operator=(const Align &Other) = default;
+  Align(Align &&Other) = default;
+  Align &operator=(Align &&Other) = default;
+
+  explicit Align(uint64_t Value) {
+    assert(Value > 0 && "Value must not be 0");
+    assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2");
+    ShiftValue = Log2_64(Value);
+  }
+
+  // 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; }
+};
+
+// Treats the value 0 as a 1, so Align is always at least 1.
+inline Align assumeAligned(uint64_t Value) {
+  return Value ? Align(Value) : Align();
+}
+
+// This struct is a compact representation of a valid (power of two) or
+// undefined (0) alignment.
+struct MaybeAlign final {
+private:
+  uint8_t ShiftValuePlusOne; // The log2 of the required alignment plus 1. This
+                             // allows using 0 as `undefined`.
+  friend unsigned encode(MaybeAlign);
+  friend MaybeAlign decodeMaybeAlign(unsigned);
+  friend bool operator==(MaybeAlign Lhs, MaybeAlign Rhs);
+  friend bool operator!=(MaybeAlign Lhs, MaybeAlign Rhs);
+  friend bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs);
+  friend bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs);
+  friend bool operator<(MaybeAlign Lhs, MaybeAlign Rhs);
+  friend bool operator>(MaybeAlign Lhs, MaybeAlign Rhs);
+
+public:
+  // Default is undefined alignment.
+  MaybeAlign() : ShiftValuePlusOne(0) {}
+  // Do not perform checks in case of copy/move construct/assign, because the
+  // checks have been performed when building `Other`.
+  MaybeAlign(const MaybeAlign &Other) = default;
+  MaybeAlign &operator=(const MaybeAlign &Other) = default;
+  MaybeAlign(MaybeAlign &&Other) = default;
+  MaybeAlign &operator=(MaybeAlign &&Other) = default;
+
+  explicit MaybeAlign(uint64_t Value) {
+    assert((Value == 0 || llvm::isPowerOf2_64(Value)) &&
+           "Alignment is not 0 or a power of 2");
+    // If Value == 0, Log2_64(Value) == -1 and then ShiftValuePlusOne == 0
+    ShiftValuePlusOne = Log2_64(Value) + 1;
+  }
+
+  // Allow construction and assignment from Align type.
+  MaybeAlign(Align Other) : ShiftValuePlusOne(Other.ShiftValue + 1) {}
+  void operator=(Align Alignement) { *this = MaybeAlign(Alignement); }
+
+  // Returns whether the alignment is set or undefined.
+  bool hasValue() const { return ShiftValuePlusOne > 0; }
+
+  // For convenience, checks whether the alignment is set.
+  // e.g. if(MaybeAlign A = GetAlignement()) { /* */ }
+  explicit operator bool() const { return ShiftValuePlusOne > 0; }
+
+  // Returns an Align from this MaybeAlign.
+  // Precondition, this alignment must be set.
+  Align getValue() const {
+    assert(hasValue() && "Can't convert undefined alignment to Align type");
+    Align A;
+    A.ShiftValue = ShiftValuePlusOne - 1;
+    return A;
+  }
+
+  // For convenience, mimics llvm:Optional access.
+  Align operator*() const { return getValue(); }
+
+  // For convenience, returns a valid alignment or 1 if undefined.
+  Align valueOrOne() const { return hasValue() ? getValue() : Align(); }
+};
+
+// -----------------------------------------------------------------------------
+// isAligned: Checks that SizeInBytes is a multiple of the alignment.
+// -----------------------------------------------------------------------------
+
+inline bool isAligned(Align Lhs, uint64_t SizeInBytes) {
+  return SizeInBytes % Lhs.value() == 0;
+}
+
+// Returns false if the alignment is undefined.
+inline bool isAligned(MaybeAlign Lhs, uint64_t SizeInBytes) {
+  ALIGN_CHECK_ISSET(Lhs);
+  return SizeInBytes % (*Lhs).value() == 0;
+}
+
+// -----------------------------------------------------------------------------
+// alignTo: Returns a multiple of A needed to store `Size` bytes.
+// -----------------------------------------------------------------------------
+
+inline uint64_t alignTo(uint64_t Size, Align A) {
+  return (Size + A.value() - 1) / A.value() * A.value();
+}
+
+// Returns `Size` if current alignment is undefined.
+inline uint64_t alignTo(uint64_t Size, MaybeAlign A) {
+  return A ? alignTo(Size, A.getValue()) : Size;
+}
+
+// -----------------------------------------------------------------------------
+// log2: Returns the log2 of the alignment.
+// e.g. Align(16).log2() == 4
+// -----------------------------------------------------------------------------
+
+inline unsigned Log2(Align A) { return A.ShiftValue; }
+
+// Returns unsigned(-1) if current alignment is undefined.
+inline unsigned Log2(MaybeAlign A) { return A ? Log2(A.getValue()) : -1; }
+
+// -----------------------------------------------------------------------------
+// commonAlignment: returns the alignment that satisfies both alignments.
+// Same semantic as MinAlign.
+// -----------------------------------------------------------------------------
+
+inline Align commonAlignment(Align A, Align B) { return std::min(A, B); }
+
+inline Align commonAlignment(Align A, uint64_t Offset) {
+  return Align(MinAlign(A.value(), Offset));
+}
+
+inline MaybeAlign commonAlignment(MaybeAlign A, MaybeAlign B) {
+  return A && B ? commonAlignment(*A, *B) : A ? A : B;
+}
+
+inline MaybeAlign commonAlignment(MaybeAlign A, uint64_t Offset) {
+  return MaybeAlign(MinAlign((*A).value(), Offset));
+}
+
+// -----------------------------------------------------------------------------
+// Encode/Decode
+// -----------------------------------------------------------------------------
+
+// Returns a more compact representation of the alignment.
+// The encoded value is positive by definition.
+// e.g. Align(1).encode() == 1
+// e.g. Align(16).encode() == 5
+inline unsigned encode(Align A) { return encode(MaybeAlign(A)); }
+
+// Returns a more compact representation of the alignment.
+// An undefined MaybeAlign is encoded as 0.
+inline unsigned encode(MaybeAlign A) { return A.ShiftValuePlusOne; }
+
+// Dual operation of the encode function above.
+inline MaybeAlign decodeMaybeAlign(unsigned Value) {
+  MaybeAlign Out;
+  Out.ShiftValuePlusOne = Value;
+  return Out;
+}
+
+// -----------------------------------------------------------------------------
+// Comparisons
+// -----------------------------------------------------------------------------
+
+// Comparisons between Align and scalars. Rhs must be positive.
+inline bool operator==(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() == Rhs;
+}
+inline bool operator!=(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() != Rhs;
+}
+inline bool operator<=(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() <= Rhs;
+}
+inline bool operator>=(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() >= Rhs;
+}
+inline bool operator<(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() < Rhs;
+}
+inline bool operator>(Align Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() > Rhs;
+}
+
+// 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();
+}
+
+// Comparisons operators between MaybeAlign.
+inline bool operator==(MaybeAlign Lhs, MaybeAlign Rhs) {
+  // Fine to compare with 0.
+  return Lhs.ShiftValuePlusOne == Rhs.ShiftValuePlusOne;
+}
+inline bool operator!=(MaybeAlign Lhs, MaybeAlign Rhs) {
+  // Fine to compare with 0.
+  return Lhs.ShiftValuePlusOne != Rhs.ShiftValuePlusOne;
+}
+inline bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.ShiftValuePlusOne <= Rhs.ShiftValuePlusOne;
+}
+inline bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.ShiftValuePlusOne >= Rhs.ShiftValuePlusOne;
+}
+inline bool operator<(MaybeAlign Lhs, MaybeAlign Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.ShiftValuePlusOne < Rhs.ShiftValuePlusOne;
+}
+inline bool operator>(MaybeAlign Lhs, MaybeAlign Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.ShiftValuePlusOne > Rhs.ShiftValuePlusOne;
+}
+
+// -----------------------------------------------------------------------------
+// Division
+// -----------------------------------------------------------------------------
+
+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);
+}
+
+inline MaybeAlign operator/(MaybeAlign Lhs, uint64_t Divisor) {
+  assert(llvm::isPowerOf2_64(Divisor) &&
+         "Divisor must be positive and a power of 2");
+  return Lhs ? Lhs.getValue() / Divisor : MaybeAlign();
+}
+
+#undef ALIGN_CHECK_ISPOSITIVE
+#undef ALIGN_CHECK_ISSET
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_ALIGNMENT_H_
diff --git a/llvm/unittests/Support/AlignmentTest.cpp b/llvm/unittests/Support/AlignmentTest.cpp
new file mode 100644
--- /dev/null
+++ b/llvm/unittests/Support/AlignmentTest.cpp
@@ -0,0 +1,273 @@
+//=== - llvm/unittest/Support/Alignment.cpp - Alignment utility tests -----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/Alignment.h"
+#include "gtest/gtest.h"
+
+#include <vector>
+
+using namespace llvm;
+
+namespace {
+
+std::vector<uint64_t> getValidAlignments() {
+  std::vector<uint64_t> Out;
+  for (size_t Shift = 0; Shift < 31; ++Shift)
+    Out.push_back(1ULL << Shift);
+  return Out;
+}
+
+std::vector<uint64_t> getNonPowerOfTwo() {
+  return {3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15};
+}
+
+TEST(Alignment, AlignDefaultCTor) { EXPECT_EQ(Align().value(), 1ULL); }
+
+TEST(Alignment, MaybeAlignDefaultCTor) {
+  EXPECT_FALSE(MaybeAlign().hasValue());
+}
+
+TEST(Alignment, ValidCTors) {
+  for (size_t Value : getValidAlignments()) {
+    EXPECT_EQ(Align(Value).value(), Value);
+    EXPECT_EQ((*MaybeAlign(Value)).value(), Value);
+  }
+}
+
+TEST(Alignment, InvalidCTors) {
+  EXPECT_DEATH((Align(0)), "Value must not be 0");
+  for (size_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(Alignment, 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(Alignment, CantConvertUnsetMaybe) {
+  EXPECT_DEATH((MaybeAlign(0).getValue()),
+               "Can't convert undefined alignment to Align type");
+}
+
+TEST(Alignment, Division) {
+  for (size_t Value : getValidAlignments()) {
+    if (Value == 1) {
+      EXPECT_DEATH(Align(Value) / 2, "Can't halve byte alignment");
+      EXPECT_DEATH(MaybeAlign(Value) / 2, "Can't halve byte alignment");
+    } else {
+      EXPECT_EQ(Align(Value) / 2, Value / 2);
+      EXPECT_EQ(MaybeAlign(Value) / 2, Value / 2);
+    }
+  }
+  EXPECT_EQ(MaybeAlign(0) / 2, MaybeAlign(0));
+
+  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(Alignment, AlignTo) {
+  struct {
+    uint64_t alignment;
+    uint64_t offset;
+    uint64_t rounded;
+  } kTests[] = {
+      // MaybeAlign
+      {0, 0, 0},
+      {0, 1, 1},
+      {0, 5, 5},
+      // MaybeAlign / Align
+      {1, 0, 0},
+      {1, 1, 1},
+      {1, 5, 5},
+      {2, 0, 0},
+      {2, 1, 2},
+      {2, 2, 2},
+      {2, 7, 8},
+      {2, 16, 16},
+      {4, 0, 0},
+      {4, 1, 4},
+      {4, 4, 4},
+      {4, 6, 8},
+  };
+  for (const auto &T : kTests) {
+    MaybeAlign A(T.alignment);
+    // Test MaybeAlign
+    EXPECT_EQ(alignTo(T.offset, A), T.rounded);
+    // Test Align
+    if (A)
+      EXPECT_EQ(alignTo(T.offset, A.getValue()), T.rounded);
+  }
+}
+
+TEST(Alignment, Log2) {
+  for (size_t Value : getValidAlignments()) {
+    EXPECT_EQ(Log2(Align(Value)), Log2_64(Value));
+    EXPECT_EQ(Log2(MaybeAlign(Value)), Log2_64(Value));
+  }
+  EXPECT_EQ(Log2(MaybeAlign(0)), (unsigned)-1);
+}
+
+TEST(Alignment, MinAlign) {
+  struct {
+    uint64_t A;
+    uint64_t B;
+    uint64_t MinAlign;
+  } kTests[] = {
+      // MaybeAlign
+      {0, 0, 0},
+      {0, 8, 8},
+      {2, 0, 2},
+      // MaybeAlign / Align
+      {1, 2, 1},
+      {8, 4, 4},
+  };
+  for (const auto &T : kTests) {
+    EXPECT_EQ(commonAlignment(MaybeAlign(T.A), MaybeAlign(T.B)), T.MinAlign);
+    EXPECT_EQ(MinAlign(T.A, T.B), T.MinAlign);
+    if (T.A)
+      EXPECT_EQ(commonAlignment(Align(T.A), MaybeAlign(T.B)), T.MinAlign);
+    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(Alignment, Encode_Decode) {
+  for (size_t Value : getValidAlignments()) {
+    {
+      Align Actual(Value);
+      Align Expected = decodeMaybeAlign(encode(Actual)).getValue();
+      EXPECT_EQ(Expected, Actual);
+    }
+    {
+      MaybeAlign Actual(Value);
+      MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
+      EXPECT_EQ(Expected, Actual);
+    }
+  }
+  MaybeAlign Actual(0);
+  MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
+  EXPECT_EQ(Expected, Actual);
+}
+
+TEST(Alignment, isAligned) {
+  struct {
+    uint64_t alignment;
+    uint64_t offset;
+    bool isAligned;
+  } kTests[] = {
+      // MaybeAlign / Align
+      {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);
+  }
+}
+
+TEST(Alignment, AlignComparisons) {
+  std::vector<size_t> ValidAlignments = getValidAlignments();
+  std::sort(ValidAlignments.begin(), ValidAlignments.end());
+  for (size_t I = 1; I < ValidAlignments.size(); ++I) {
+    assert(I >= 1);
+    const Align A(ValidAlignments[I - 1]);
+    const Align B(ValidAlignments[I]);
+    EXPECT_EQ(A, A);
+    EXPECT_NE(A, B);
+    EXPECT_LT(A, B);
+    EXPECT_GT(B, A);
+    EXPECT_LE(A, B);
+    EXPECT_GE(B, A);
+    EXPECT_LE(A, A);
+    EXPECT_GE(A, A);
+
+    EXPECT_EQ(A, A.value());
+    EXPECT_NE(A, B.value());
+    EXPECT_LT(A, B.value());
+    EXPECT_GT(B, A.value());
+    EXPECT_LE(A, B.value());
+    EXPECT_GE(B, A.value());
+    EXPECT_LE(A, A.value());
+    EXPECT_GE(A, A.value());
+
+    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(Alignment, AssumeAligned) {
+  EXPECT_EQ(assumeAligned(0), Align(1));
+  EXPECT_EQ(assumeAligned(0), Align());
+  EXPECT_EQ(assumeAligned(1), Align(1));
+  EXPECT_EQ(assumeAligned(1), Align());
+}
+
+TEST(Alignment, ComparisonsWithZero) {
+  for (size_t Value : getValidAlignments()) {
+    // Compare Align to 0.
+    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");
+
+    // Compare MaybeAlign to 0, MaybeAlign is allowed to be == or != 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");
+
+    // Compare Align to undefined MaybeAlign
+    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");
+  }
+}
+
+} // end anonymous namespace
diff --git a/llvm/unittests/Support/CMakeLists.txt b/llvm/unittests/Support/CMakeLists.txt
--- a/llvm/unittests/Support/CMakeLists.txt
+++ b/llvm/unittests/Support/CMakeLists.txt
@@ -3,6 +3,7 @@
   )
 
 add_llvm_unittest(SupportTests
+  AlignmentTest.cpp
   AlignOfTest.cpp
   AllocatorTest.cpp
   AnnotationsTest.cpp