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,570 @@
+//===-- 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 get() 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 THIRD_PARTY_LLVM_LLVM_INCLUDE_LLVM_SUPPORT_ALIGNMENT_H_
+#define THIRD_PARTY_LLVM_LLVM_INCLUDE_LLVM_SUPPORT_ALIGNMENT_H_
+
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/MathExtras.h"
+#include <cassert>
+#include <limits>
+
+namespace llvm {
+
+// FIXME: Enable when all the call sites are fixed to check correct alignment
+// semantic.
+#define ALIGN_HARDENED_ALIGNMENT 0
+
+#if ALIGN_HARDENED_ALIGNMENT
+#define ALIGN_CHECK_ISPOSITIVE(decl)                                           \
+  assert(decl > 0 && (#decl " should be defined"))
+#define ALIGN_CHECK_ISSET(decl)                                                \
+  assert(decl.isSet() && (#decl " should be defined"))
+#define ALIGN_DEPRECATED(decl, message) LLVM_ATTRIBUTE_DEPRECATED(decl, message)
+#else
+#define ALIGN_CHECK_ISPOSITIVE(decl)
+#define ALIGN_CHECK_ISSET(decl)
+#define ALIGN_DEPRECATED(decl, message) decl
+#endif
+
+// This struct is a compact representation of a valid (non-zero power of two)
+// alignment.
+// Its minimum value is 1, its maximum value is 2^31, 2^32 is excluded on
+// purpose to prevent mixing it up with -1.
+// It is suitable for use as static global constants.
+struct Align final {
+private:
+  uint32_t Value; // The alignment value in Bytes.
+  friend struct MaybeAlign;
+
+public:
+  // Default is byte-aligned.
+  Align() : Value(1) {}
+  // 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) : Value(Value) {
+    assert(Value < std::numeric_limits<uint32_t>::max() && "Value too big");
+    assert(Value > 0 && "Value must not be 0");
+    assert(llvm::isPowerOf2_64(Value) && "Alignment is not a power of 2");
+  }
+
+  // A safe halving method that makes sure semantic is preserved.
+  Align half() const {
+    assert(Value > 1 && "Can't halve byte alignment");
+    return Align(Value / 2);
+  }
+
+  // Whether we need extra bytes after storing `Size` bytes to keep the current
+  // alignment.
+  bool needsPadding(uint64_t Size) const {
+    return (Size & (uint64_t(Value) - 1)) != 0;
+  }
+
+  // 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 Value; }
+};
+
+// This struct is a compact representation of a valid (power of two) or
+// undefined (0) alignment.
+// Its minimum value is 0, its maximum value is 2^31, 2^32 is excluded on
+// purpose to prevent mixing it up with -1.
+// It is suitable for use as static global constants.
+struct MaybeAlign final {
+private:
+  uint32_t Value;
+
+public:
+  static constexpr unsigned kSentinel = std::numeric_limits<unsigned>::max();
+
+  // Default is undefined alignment.
+  MaybeAlign() : Value(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) : Value(Value) {
+    assert(Value < std::numeric_limits<uint32_t>::max() && "Value too big");
+    assert((Value == 0 || llvm::isPowerOf2_64(Value)) &&
+           "Alignment is not 0 or a power of 2");
+  }
+
+  // Allow construction and assignment from Align type.
+  MaybeAlign(const Align &Other) : Value(Other.Value) {}
+  void operator=(const Align &Alignement) { *this = MaybeAlign(Alignement); }
+
+  // For convenience, checks whether the alignment is set.
+  // e.g. if(MaybeAlign A = GetAlignement()) { /* */ }
+  explicit operator bool() const { return Value > 0; }
+
+  // Returns whether the alignment is set or undefined.
+  bool isSet() const { return Value > 0; }
+
+  // Returns an Align from this MaybeAlign.
+  // Precondition, this alignment must be set.
+  Align get() const {
+    assert(isSet() && "Can't convert undefined alignment to Align type");
+    return Align(Value);
+  }
+
+  // Convenient method to help straighten the alignment. MaybeAlign types after
+  // this point can be turned into Align.
+  void mustBeSetAtThisPoint() const {
+    assert(Value && "Alignment must be set at this point");
+  }
+
+  // For convenience, returns a valid alignment or 1 if undefined.
+  Align valueOrOne() const { return Value ? Align(Value) : Align(1); }
+
+  // This is a hole in the type system and should not be abused.
+  // Needed to interact with C for instance.
+  unsigned safeValue() const {
+    assert(Value && "Can't return an unset alignment");
+    return Value;
+  }
+
+  // This is a hole in the type system and should not be abused.
+  // Needed to interact with C for instance.
+  uint64_t rawValue() const { return Value; }
+
+  // See Align::needsPadding for documentation. Returns false if current
+  // alignment is undefined.
+  // FIXME: /!\ this method hides the undefined semantics and should be removed
+  // once the call sites are updated.
+  ALIGN_DEPRECATED(
+      bool needsPadding(uint64_t Size) const,
+      "needsPadding involving MaybeAlign mixes semantics, use Align instead");
+
+  // See Align::half for documentation. Returns undefined alignment if current
+  // alignment is undefined.
+  // FIXME: /!\ this method hides the undefined semantics and should be removed
+  // once the call sites are updated.
+  ALIGN_DEPRECATED(
+      MaybeAlign half() const,
+      "half involving MaybeAlign mixes semantics, use Align instead");
+};
+
+inline bool MaybeAlign::needsPadding(uint64_t Size) const {
+  return Value ? Align(Value).needsPadding(Size) : false;
+}
+
+inline MaybeAlign MaybeAlign::half() const {
+  return Value ? Align(Value).half() : MaybeAlign();
+}
+
+// -----------------------------------------------------------------------------
+// isAligned: Checks that SizeInBytes is a multiple of the alignment.
+// -----------------------------------------------------------------------------
+
+inline bool isAligned(const Align &Lhs, uint64_t SizeInBytes) {
+  return SizeInBytes % Lhs.value() == 0;
+}
+
+// FIXME: /!\ this method hides the undefined semantics and should be removed
+// once the call sites are updated.
+ALIGN_DEPRECATED(
+    bool isAligned(const MaybeAlign &Lhs, uint64_t SizeInBytes),
+    "isAligned involving MaybeAlign mixes semantics, use Align instead");
+
+// Returns false if the alignment is undefined.
+inline bool isAligned(const MaybeAlign &Lhs, uint64_t SizeInBytes) {
+  ALIGN_CHECK_ISSET(Lhs);
+  return SizeInBytes % Lhs.rawValue() == 0;
+}
+
+// This function is here for the purpose of refactoring the LLVM's alignment but
+// seems to be logically wrong.
+// Checks that alignment is a multiple of the SizeInBytes. e.g.
+// isAlignedBogus(Align(4), 4) == true
+// isAlignedBogus(Align(2), 4) == false
+// isAlignedBogus(Align(8), 4) == true
+// isAlignedBogus(Align(2), 5) == false
+inline bool isAlignedBogus(const Align &Lhs, uint64_t SizeInBytes) {
+  ALIGN_CHECK_ISPOSITIVE(SizeInBytes);
+  return Lhs.value() % SizeInBytes == 0;
+}
+
+// This function is here for the purpose of refactoring the LLVM's alignment but
+// seems to be logically wrong.
+// Checks that alignment is a multiple of the SizeInBytes.
+// Returns false if the alignment is undefined. e.g.
+// isAlignedBogus(MaybeAlign(0), 4) == false
+// isAlignedBogus(MaybeAlign(4), 4) == true
+// isAlignedBogus(MaybeAlign(2), 4) == false
+// isAlignedBogus(MaybeAlign(8), 4) == true
+// isAlignedBogus(MaybeAlign(2), 5) == false
+inline bool isAlignedBogus(const MaybeAlign &Lhs, uint64_t SizeInBytes) {
+  ALIGN_CHECK_ISPOSITIVE(SizeInBytes);
+  ALIGN_CHECK_ISSET(Lhs);
+  return Lhs.rawValue() % SizeInBytes == 0;
+}
+
+// -----------------------------------------------------------------------------
+// alignTo: Returns a multiple of A needed to store `Size` bytes.
+// -----------------------------------------------------------------------------
+
+inline uint64_t alignTo(uint64_t Size, const Align &A) {
+  return (Size + A.value() - 1) / A.value() * A.value();
+}
+
+// FIXME: /!\ this method hides the undefined semantics and should be removed
+// once the call sites are updated.
+ALIGN_DEPRECATED(
+    uint64_t alignTo(uint64_t Size, const MaybeAlign &A),
+    "roundUp involving MaybeAlign mixes semantics, use Align instead");
+
+// Returns `Size` if current alignment is undefined.
+inline uint64_t alignTo(uint64_t Size, const MaybeAlign &A) {
+  return A ? alignTo(Size, A.get()) : Size;
+}
+
+// -----------------------------------------------------------------------------
+// log2: Returns the log2 of the alignment.
+// e.g. Align(16).log2() == 4
+// -----------------------------------------------------------------------------
+
+inline unsigned Log2_32(const Align &A) { return Log2_32(A.value()); }
+
+// FIXME: /!\ this method hides the undefined semantics and should be removed
+// once the call sites are updated.
+ALIGN_DEPRECATED(
+    unsigned Log2_32(const MaybeAlign &A),
+    "log2 involving MaybeAlign mixes semantics, use Align instead");
+
+// Returns unsigned(-1) if current alignment is undefined.
+inline unsigned Log2_32(const MaybeAlign &A) {
+  return A ? Log2_32(A.get()) : MaybeAlign::kSentinel;
+}
+
+// -----------------------------------------------------------------------------
+// commonAlignment: returns the alignment that satisfies both alignments.
+// Same semantic as MinAlign.
+// -----------------------------------------------------------------------------
+
+inline Align commonAlignment(const Align &A, const Align &B) {
+  return Align(MinAlign(A.value(), B.value()));
+}
+
+inline Align commonAlignment(const Align &A, uint64_t Offset) {
+  return Align(MinAlign(A.value(), Offset));
+}
+
+ALIGN_DEPRECATED(
+    MaybeAlign commonAlignment(const MaybeAlign &A, const MaybeAlign &B),
+    "commonAlignment involving MaybeAlign mixes semantics, use Align instead");
+
+ALIGN_DEPRECATED(
+    Align commonAlignment(const MaybeAlign &A, uint64_t Offset),
+    "commonAlignment involving MaybeAlign mixes semantics, use Align instead");
+
+inline MaybeAlign commonAlignment(const MaybeAlign &A, const MaybeAlign &B) {
+  return MaybeAlign(MinAlign(A.rawValue(), B.rawValue()));
+}
+
+inline Align commonAlignment(const MaybeAlign &A, uint64_t Offset) {
+  return commonAlignment(A.get(), 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(const Align &A) { return Log2_32(A.value()) + 1; }
+
+// Returns a more compact representation of the alignment.
+// An undefined MaybeAlign is encoded as 0.
+inline unsigned encode(const MaybeAlign &A) {
+  return Log2_32(A.rawValue()) + 1;
+}
+
+// Dual operation of the encode function above.
+inline MaybeAlign decodeMaybeAlign(unsigned Value) {
+  return MaybeAlign((1U << Value) / 2);
+}
+
+// -----------------------------------------------------------------------------
+// Comparisons
+// -----------------------------------------------------------------------------
+
+// Comparisons between Align and scalars. Rhs must be positive.
+inline bool operator==(const Align &Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() == Rhs;
+}
+inline bool operator!=(const Align &Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() != Rhs;
+}
+inline bool operator<=(const Align &Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() <= Rhs;
+}
+inline bool operator>=(const Align &Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() >= Rhs;
+}
+inline bool operator<(const Align &Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() < Rhs;
+}
+inline bool operator>(const Align &Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.value() > Rhs;
+}
+
+// Comparisons between MaybeAlign and scalars.
+bool operator==(const MaybeAlign &Lhs, uint64_t Rhs) {
+  // Fine to compare with 0.
+  return Lhs.rawValue() == Rhs;
+}
+bool operator!=(const MaybeAlign &Lhs, uint64_t Rhs) {
+  // Fine to compare with 0.
+  return Lhs.rawValue() != Rhs;
+}
+bool operator<=(const MaybeAlign &Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.rawValue() <= Rhs;
+}
+bool operator>=(const MaybeAlign &Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.rawValue() >= Rhs;
+}
+bool operator<(const MaybeAlign &Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.rawValue() < Rhs;
+}
+bool operator>(const MaybeAlign &Lhs, uint64_t Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISPOSITIVE(Rhs);
+  return Lhs.rawValue() > Rhs;
+}
+
+// Comparisons operators between Align.
+inline bool operator==(const Align &Lhs, const Align &Rhs) {
+  return Lhs.value() == Rhs.value();
+}
+inline bool operator!=(const Align &Lhs, const Align &Rhs) {
+  return Lhs.value() != Rhs.value();
+}
+inline bool operator<=(const Align &Lhs, const Align &Rhs) {
+  return Lhs.value() <= Rhs.value();
+}
+inline bool operator>=(const Align &Lhs, const Align &Rhs) {
+  return Lhs.value() >= Rhs.value();
+}
+inline bool operator<(const Align &Lhs, const Align &Rhs) {
+  return Lhs.value() < Rhs.value();
+}
+inline bool operator>(const Align &Lhs, const Align &Rhs) {
+  return Lhs.value() > Rhs.value();
+}
+
+// Comparisons operators between Align and MaybeAlign.
+inline bool operator==(const Align &Lhs, const MaybeAlign &Rhs) {
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.value() == Rhs.rawValue();
+}
+inline bool operator!=(const Align &Lhs, const MaybeAlign &Rhs) {
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.value() != Rhs.rawValue();
+}
+inline bool operator<=(const Align &Lhs, const MaybeAlign &Rhs) {
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.value() <= Rhs.rawValue();
+}
+inline bool operator>=(const Align &Lhs, const MaybeAlign &Rhs) {
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.value() >= Rhs.rawValue();
+}
+inline bool operator<(const Align &Lhs, const MaybeAlign &Rhs) {
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.value() < Rhs.rawValue();
+}
+inline bool operator>(const Align &Lhs, const MaybeAlign &Rhs) {
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.value() > Rhs.rawValue();
+}
+
+// Comparisons operators between MaybeAlign and Align.
+inline bool operator==(const MaybeAlign &Lhs, const Align &Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  return Lhs.rawValue() == Rhs.value();
+}
+inline bool operator!=(const MaybeAlign &Lhs, const Align &Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  return Lhs.rawValue() != Rhs.value();
+}
+inline bool operator<=(const MaybeAlign &Lhs, const Align &Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  return Lhs.rawValue() <= Rhs.value();
+}
+inline bool operator>=(const MaybeAlign &Lhs, const Align &Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  return Lhs.rawValue() >= Rhs.value();
+}
+inline bool operator<(const MaybeAlign &Lhs, const Align &Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  return Lhs.rawValue() < Rhs.value();
+}
+inline bool operator>(const MaybeAlign &Lhs, const Align &Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  return Lhs.rawValue() > Rhs.value();
+}
+
+// Comparisons operators between MaybeAlign.
+bool operator==(const MaybeAlign &Lhs, const MaybeAlign &Rhs) {
+  // Fine to compare with 0.
+  return Lhs.rawValue() == Rhs.rawValue();
+}
+bool operator!=(const MaybeAlign &Lhs, const MaybeAlign &Rhs) {
+  // Fine to compare with 0.
+  return Lhs.rawValue() != Rhs.rawValue();
+}
+bool operator<=(const MaybeAlign &Lhs, const MaybeAlign &Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.rawValue() <= Rhs.rawValue();
+}
+bool operator>=(const MaybeAlign &Lhs, const MaybeAlign &Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.rawValue() >= Rhs.rawValue();
+}
+bool operator<(const MaybeAlign &Lhs, const MaybeAlign &Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.rawValue() < Rhs.rawValue();
+}
+bool operator>(const MaybeAlign &Lhs, const MaybeAlign &Rhs) {
+  ALIGN_CHECK_ISSET(Lhs);
+  ALIGN_CHECK_ISSET(Rhs);
+  return Lhs.rawValue() > Rhs.rawValue();
+}
+
+// -----------------------------------------------------------------------------
+// max: Returns the greatest of the two alignments.
+// -----------------------------------------------------------------------------
+
+// The maximum of two valid alignments is a valid alignment.
+inline Align max(const Align &A, const Align &B) { return A > B ? A : B; }
+
+// FIXME: /!\ this method hides the undefined semantics and should be removed
+// once the call sites are updated.
+ALIGN_DEPRECATED(MaybeAlign max(const MaybeAlign &A, const MaybeAlign &B),
+                 "max involving MaybeAlign mixes semantics, use Align instead");
+
+// FIXME: /!\ this method hides the undefined semantics and should be removed
+// once the call sites are updated.
+ALIGN_DEPRECATED(Align max(const Align &A, const MaybeAlign &B),
+                 "max involving MaybeAlign mixes semantics, use Align instead");
+
+// FIXME: /!\ this method hides the undefined semantics and should be removed
+// once the call sites are updated.
+ALIGN_DEPRECATED(Align max(const MaybeAlign &A, const Align &B),
+                 "max involving MaybeAlign mixes semantics, use Align instead");
+
+inline MaybeAlign max(const MaybeAlign &A, const MaybeAlign &B) {
+  return MaybeAlign(std::max(A.rawValue(), B.rawValue()));
+}
+
+inline Align max(const Align &A, const MaybeAlign &B) {
+  return Align(std::max(A.value(), B.rawValue()));
+}
+
+inline Align max(const MaybeAlign &A, const Align &B) {
+  return Align(std::max(A.rawValue(), B.value()));
+}
+
+// -----------------------------------------------------------------------------
+// min: Returns the smallest of the two alignments.
+// -----------------------------------------------------------------------------
+
+// The minimum of two valid alignments is a valid alignment.
+inline Align min(const Align &A, const Align &B) { return A > B ? B : A; }
+
+// FIXME: /!\ this method hides the undefined semantics and should be removed
+// once the call sites are updated.
+ALIGN_DEPRECATED(MaybeAlign min(const MaybeAlign &A, const MaybeAlign &B),
+                 "min involving MaybeAlign mixes semantics, use Align instead");
+
+// FIXME: /!\ this method hides the undefined semantics and should be removed
+// once the call sites are updated.
+ALIGN_DEPRECATED(MaybeAlign min(const Align &A, const MaybeAlign &B),
+                 "min involving MaybeAlign mixes semantics, use Align instead");
+
+// FIXME: /!\ this method hides the undefined semantics and should be removed
+// once the call sites are updated.
+ALIGN_DEPRECATED(MaybeAlign min(const MaybeAlign &A, const Align &B),
+                 "min involving MaybeAlign mixes semantics, use Align instead");
+
+inline MaybeAlign min(const MaybeAlign &A, const MaybeAlign &B) {
+  return MaybeAlign(std::min(A.rawValue(), B.rawValue()));
+}
+
+inline MaybeAlign min(const Align &A, const MaybeAlign &B) {
+  return MaybeAlign(std::min(A.value(), B.rawValue()));
+}
+
+inline MaybeAlign min(const MaybeAlign &A, const Align &B) {
+  return MaybeAlign(std::min(A.rawValue(), B.value()));
+}
+
+#undef ALIGN_CHECK_ISPOSITIVE
+#undef ALIGN_CHECK_ISSET
+#undef ALIGN_DEPRECATED
+
+} // namespace llvm
+
+#endif // THIRD_PARTY_LLVM_LLVM_INCLUDE_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,284 @@
+//=== - 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};
+}
+
+std::vector<uint64_t> getAlignmentTooBig() {
+  return {std::numeric_limits<uint32_t>::max() /*2^32*/,
+          std::numeric_limits<uint64_t>::max() /*2^64*/};
+}
+
+TEST(Alignment, AlignDefaultCTor) { EXPECT_EQ(Align().value(), 1ULL); }
+
+TEST(Alignment, MaybeAlignDefaultCTor) {
+  EXPECT_EQ(MaybeAlign().rawValue(), 0ULL);
+}
+
+TEST(Alignment, ValidCTors) {
+  for (size_t Value : getValidAlignments()) {
+    EXPECT_EQ(Align(Value).value(), Value);
+    EXPECT_EQ(MaybeAlign(Value).safeValue(), Value);
+  }
+  EXPECT_EQ(MaybeAlign(0).rawValue(), 0ULL);
+}
+
+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");
+  }
+  for (size_t Value : getAlignmentTooBig()) {
+    EXPECT_DEATH((Align(Value)), "Value too big");
+    EXPECT_DEATH((MaybeAlign(Value)), "Value too big");
+  }
+}
+
+TEST(Alignment, CheckMaybeAlignIsSet) {
+  EXPECT_TRUE(MaybeAlign(1));
+  EXPECT_TRUE(MaybeAlign(1).isSet());
+  EXPECT_FALSE(MaybeAlign(0));
+  EXPECT_FALSE(MaybeAlign(0).isSet());
+  EXPECT_FALSE(MaybeAlign());
+  EXPECT_FALSE(MaybeAlign().isSet());
+}
+
+TEST(Alignment, CantConvertUnsetMaybe) {
+  EXPECT_DEATH((MaybeAlign(0).get()),
+               "Can't convert undefined alignment to Align type");
+  EXPECT_DEATH((MaybeAlign(0).safeValue()), "Can't return an unset alignment");
+}
+
+TEST(Alignment, Half) {
+  for (size_t Value : getValidAlignments()) {
+    if (Value == 1) {
+      EXPECT_DEATH(Align(Value).half(), "Can't halve byte alignment");
+      EXPECT_DEATH(MaybeAlign(Value).half(), "Can't halve byte alignment");
+    } else {
+      EXPECT_EQ(Align(Value).half(), Value / 2);
+      EXPECT_EQ(MaybeAlign(Value).half(), Value / 2);
+    }
+  }
+  EXPECT_EQ(MaybeAlign(0).half(), MaybeAlign(0));
+}
+
+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.get()), T.rounded);
+  }
+}
+
+TEST(Alignment, NeedsPadding) {
+  struct {
+    uint64_t alignment;
+    uint64_t offset;
+    bool needsPadding;
+  } kTests[] = {
+      // MaybeAlign
+      {0, 0, false},
+      {0, 1, false},
+      {0, 5, false},
+      // MaybeAlign / Align
+      {1, 0, false},
+      {1, 1, false},
+      {1, 5, false},
+      {2, 0, false},
+      {2, 1, true},
+      {2, 2, false},
+      {2, 7, true},
+      {2, 16, false},
+      {4, 0, false},
+      {4, 1, true},
+      {4, 4, false},
+      {4, 6, true},
+  };
+  for (const auto &T : kTests) {
+    MaybeAlign A(T.alignment);
+    // Test MaybeAlign
+    EXPECT_EQ(A.needsPadding(T.offset), T.needsPadding);
+    // Test Align
+    if (A)
+      EXPECT_EQ(A.get().needsPadding(T.offset), T.needsPadding);
+  }
+}
+
+TEST(Alignment, Log2_32) {
+  for (size_t Value : getValidAlignments()) {
+    EXPECT_EQ(Log2_32(Align(Value)), Log2_64(Value));
+    EXPECT_EQ(Log2_32(MaybeAlign(Value)), Log2_64(Value));
+  }
+  EXPECT_EQ(Log2_32(MaybeAlign(0)), (unsigned)-1);
+}
+
+TEST(Alignment, Encode_Decode) {
+  for (size_t Value : getValidAlignments()) {
+    {
+      Align Actual(Value);
+      Align Expected = decodeMaybeAlign(encode(Actual)).get();
+      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.get(), 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(max(A, B), B);
+    EXPECT_EQ(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.safeValue());
+    EXPECT_NE(MA, MB.safeValue());
+    EXPECT_LT(MA, MB.safeValue());
+    EXPECT_GT(MB, MA.safeValue());
+    EXPECT_LE(MA, MB.safeValue());
+    EXPECT_GE(MB, MA.safeValue());
+    EXPECT_LE(MA, MA.safeValue());
+    EXPECT_GE(MA, MA.safeValue());
+
+    EXPECT_EQ(max(A, B), B);
+    EXPECT_EQ(min(A, B), A);
+  }
+}
+
+#if ALIGN_HARDENED_ALIGNMENT
+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");
+  }
+}
+#endif
+
+} // 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