diff --git a/llvm/include/llvm/ADT/Bitfields.h b/llvm/include/llvm/ADT/Bitfields.h
new file mode 100644
--- /dev/null
+++ b/llvm/include/llvm/ADT/Bitfields.h
@@ -0,0 +1,270 @@
+//===-- llvm/ADT/Bitfield.h - Get and Set bits in an integer ---*- 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements methods to test, set and extract typed bits from packed
+/// unsigned integers.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_BITFIELDS_H
+#define LLVM_ADT_BITFIELDS_H
+
+#include <cassert>
+#include <climits> // CHAR_BIT
+#include <cstddef> // size_t
+#include <cstdint> // uintXX_t
+#include <limits>  // numeric_limits
+#include <type_traits>
+
+/// Helpers to pack / unpack typed bitfields into an unsigned integer.
+/// e.g.
+///
+///  uint8_t storage = 0;
+///
+///  // Store and retrieve a single bit as bool.
+///  using Bool = Bitfield<bool, 0, 1>;
+///  setField<Bool>(storage, true);
+///  EXPECT_EQ(storage, 0b00000001);
+///  //                          ^
+///  EXPECT_EQ(getField<Bool>(storage), true);
+///
+///  // Store and retrieve a 2 bit typed enum.
+///  // Note: enum underlying type must be unsigned.
+///  enum class SuitEnum : uint8_t { CLUBS, DIAMONDS, HEARTS, SPADES };
+///  // Note: enum maximum value needs to be passed in.
+///  using Suit = Bitfield<SuitEnum, 1, 2, SuitEnum::SPADES>;
+///  setField<Suit>(storage, SuitEnum::HEARTS);
+///  EXPECT_EQ(storage, 0b00000101);
+///  //                        ^^
+///  EXPECT_EQ(getField<Suit>(storage), SuitEnum::HEARTS);
+///
+///  // Store and retrieve a 5 bit value as unsigned.
+///  using Value = Bitfield<unsigned, 3, 5>;
+///  setField<Value>(storage, 10);
+///  EXPECT_EQ(storage, 0b01010101);
+///  //                   ^^^^^
+///  EXPECT_EQ(getField<Value>(storage), 10U);
+///
+///  // Interpret the same 5 bit value as signed.
+///  using SignedValue = Bitfield<int, 3, 5>;
+///  setField<SignedValue>(storage, -2);
+///  EXPECT_EQ(storage, 0b11110101);
+///  //                   ^^^^^
+///  EXPECT_EQ(getField<SignedValue>(storage), -2);
+///
+///  // Ability to efficiently test if a field is non zero.
+///  EXPECT_TRUE(testField<Value>(storage) != 0U);
+///
+///  // Alter storage changes value.
+///  storage = 0;
+///  EXPECT_EQ(getField<Bool>(storage), false);
+///  EXPECT_EQ(getField<Suit>(storage), SuitEnum::CLUBS);
+///  EXPECT_EQ(getField<Value>(storage), 0U);
+///  EXPECT_EQ(getField<SignedValue>(storage), 0);
+///
+///  storage = 255;
+///  EXPECT_EQ(getField<Bool>(storage), true);
+///  EXPECT_EQ(getField<Suit>(storage), SuitEnum::SPADES);
+///  EXPECT_EQ(getField<Value>(storage), 31U);
+///  EXPECT_EQ(getField<SignedValue>(storage), -1);
+
+namespace llvm {
+
+namespace details {
+
+/// A struct defining useful bit patterns for n-bits integer types.
+template <typename T, unsigned bits> struct BitPatterns {
+  // Bit patterns are forged using the equivalent unsigned type U because of
+  // undefined operations over signed types (e.g. Bitwise shift operators).
+  // Moreover same size casting from unsigned to signed is well defined but the
+  // opposite is not.
+  using U = typename std::make_unsigned<T>::type;
+  static_assert(sizeof(U) == sizeof(T), "Types must have same size");
+
+  static constexpr unsigned type_bits = sizeof(U) * CHAR_BIT;
+  static_assert(type_bits >= bits, "n-bit must fit in T");
+
+  // e.g. with type_bits == 8 and bits == 6.
+  static constexpr U all_zeros = U(0);                      // 0b00000000
+  static constexpr U all_ones = ~U(0);                      // 0b11111111
+  static constexpr U umin = all_zeros;                      // 0b00000000
+  static constexpr U umax = all_ones >> (type_bits - bits); // 0b00111111
+  static constexpr U sign_bit_mask = U(1) << (bits - 1U);   // 0b00100000
+  static constexpr U smax = umax >> 1U;                     // 0b00011111
+  static constexpr U smin = ~smax;                          // 0b11100000
+  static constexpr U sign_extend = smin << 1U;              // 0b11000000
+};
+
+/// `Compressor` is used to manipulate the bits of a (possibly signed) integer
+/// type so it can be packed and unpacked into a `bits` sized integer,
+/// `Compressor` is specialized on signed-ness so no runtime cost is incurred.
+/// The `pack` method also checks that the passed in `user_value` is valid.
+template <typename type, unsigned bits, bool = std::is_unsigned<type>::value>
+struct Compressor {
+  static_assert(std::is_unsigned<type>::value, "type is unsigned");
+  using BP = BitPatterns<type, bits>;
+
+  static type pack(type user_value, type user_max_value) {
+    assert(user_value <= user_max_value && "value is too big");
+    assert(user_value <= BP::umax && "value is too big");
+    return user_value;
+  }
+
+  static type unpack(type storage_value) { return storage_value; }
+};
+
+template <typename type, unsigned bits> struct Compressor<type, bits, false> {
+  static_assert(std::is_signed<type>::value, "type is signed");
+  using BP = BitPatterns<type, bits>;
+
+  static type pack(type user_value, type user_max_value) {
+    assert(user_value <= user_max_value && "value is too big");
+    assert(user_value <= type(BP::smax) && "value is too big");
+    assert(user_value >= type(BP::smin) && "value is too small");
+    if (user_value < 0)
+      user_value &= ~BP::sign_extend;
+    return user_value;
+  }
+
+  static type unpack(type storage_value) {
+    if (storage_value >= type(BP::sign_bit_mask))
+      storage_value |= BP::sign_extend;
+    return storage_value;
+  }
+};
+
+/// `bitfield_properties` stores important properties about the Bitfield.
+/// It only deals with integer types (conversion from/to enum/bool are done
+/// outside of this template).
+template <typename T, unsigned Offset, unsigned Bits,
+          T MaxValue = std::numeric_limits<T>::max(),
+          T MinValue = std::numeric_limits<T>::min()>
+struct bitfield_properties {
+  using integer_type = T;
+  static_assert(std::is_integral<T>::value &&
+                    std::numeric_limits<T>::is_integer,
+                "T must be an integer type");
+
+  static constexpr size_t type_bits = sizeof(integer_type) * CHAR_BIT;
+  static constexpr unsigned offset = Offset;
+  static constexpr unsigned bits = Bits;
+  static constexpr unsigned first_bit = offset;
+  static constexpr unsigned last_bit = offset + bits;
+  static constexpr integer_type min_value = MinValue;
+  static constexpr integer_type max_value = MaxValue;
+
+  static_assert(bits > 0, "Bits must be non zero");
+  static_assert(bits <= type_bits, "Bits may not be greater than T size");
+
+  /// Impl is where Bifield description and storage are put together to interact
+  /// with values.
+  template <typename storage_type> struct Impl {
+    static_assert(std::is_unsigned<storage_type>::value,
+                  "Storage must be unsigned");
+    using C = Compressor<integer_type, bits>;
+    using BP = BitPatterns<storage_type, bits>;
+
+    static constexpr size_t storage_bits = sizeof(storage_type) * CHAR_BIT;
+    static_assert(first_bit <= storage_bits, "Data must fit in mask");
+    static_assert(last_bit <= storage_bits, "Data must fit in mask");
+    static constexpr storage_type mask = BP::umax << offset;
+
+    /// Checks `user_value` is within bounds and packs it between `first_bit`
+    /// and `last_bit` of `packed_value` leaving the rest unchanged.
+    static void Update(storage_type &packed, integer_type user_value) {
+      const storage_type storage_value = C::pack(user_value, max_value);
+      packed &= ~mask;
+      packed |= storage_value << offset;
+    }
+
+    /// Interprets bits between `first_bit` and `last_bit` of `packed` as an
+    /// `integer_value`.
+    static integer_type Extract(storage_type packed) {
+      const storage_type storage_value = (packed & mask) >> offset;
+      return C::unpack(storage_value);
+    }
+  };
+};
+
+/// `Bitfield` deals with unsigned enums, signed/unsigned integer and `bool`
+/// internally though we only manipulate integer with well defined and
+/// consistent semantic, this excludes typed enums and `bool` that are
+/// replaced with their unsigned counterparts.
+/// The correct type is restored in the public API.
+template <typename T, bool = std::is_enum<T>::value>
+struct resolve_underlying_type {
+  using type = typename std::underlying_type<T>::type;
+};
+template <typename T> struct resolve_underlying_type<T, false> {
+  using type = T;
+};
+template <> struct resolve_underlying_type<bool, false> {
+  /// In case sizeof(bool) != 1, replace `void` by an additionnal
+  /// std::conditionnal.
+  using type = std::conditional<sizeof(bool) == 1, uint8_t, void>::type;
+};
+
+} // namespace details
+
+/// A struct to hold the bitfield informations.
+/// \param Type, the type of the field once in unpacked form,
+/// \param Offset, the position of the first bit,
+/// \param Size, the size of the field,
+/// \param MaxValue, For enums the maximum enum allowed.
+template <typename Type, unsigned Offset, unsigned Size,
+          Type MaxValue = std::is_enum<Type>::value
+                              ? Type(0) // coupled with static_assert below
+                              : std::numeric_limits<Type>::max()>
+struct Bitfield {
+  using type = Type;
+  using integer_type = typename details::resolve_underlying_type<Type>::type;
+  using properties = typename details::bitfield_properties<
+      integer_type, Offset, Size, static_cast<integer_type>(MaxValue)>;
+
+  static constexpr bool is_enum = std::is_enum<Type>::value;
+  static_assert(!is_enum || MaxValue != Type(0),
+                "Enum Bitfields must provide a MaxValue");
+  static_assert(!is_enum || std::is_unsigned<integer_type>::value,
+                "Enum must be unsigned");
+};
+
+/// Returns whether the two bitfields share common bits.
+template <typename A, typename B> static constexpr bool isOverlapping() {
+  using PA = typename A::properties;
+  using PB = typename B::properties;
+  return PA::last_bit > PB::first_bit && PB::last_bit > PA::first_bit;
+}
+
+/// Unpacks the field from the packed value.
+template <typename Bitfield, typename StorageType>
+static typename Bitfield::type getField(StorageType packed) {
+  using Impl = typename Bitfield::properties::template Impl<StorageType>;
+  return static_cast<typename Bitfield::type>(Impl::Extract(packed));
+}
+
+/// Return a non-zero value if the field is non-zero.
+/// It is more efficient than `getField`.
+template <typename Bitfield, typename StorageType>
+static StorageType testField(StorageType packed) {
+  using Impl = typename Bitfield::properties::template Impl<StorageType>;
+  return packed & Impl::mask;
+}
+
+/// Sets the typed value in the provided packed value.
+/// The method will asserts if the provided value is too big to fit in the
+/// packed field.
+template <typename Bitfield, typename StorageType>
+static void setField(StorageType &packed, typename Bitfield::type value) {
+  using Impl = typename Bitfield::properties::template Impl<StorageType>;
+  Impl::Update(packed, static_cast<typename Bitfield::integer_type>(value));
+}
+
+} // namespace llvm
+
+#endif // LLVM_ADT_BITFIELDS_H
\ No newline at end of file
diff --git a/llvm/unittests/ADT/BitFieldsTest.cpp b/llvm/unittests/ADT/BitFieldsTest.cpp
new file mode 100644
--- /dev/null
+++ b/llvm/unittests/ADT/BitFieldsTest.cpp
@@ -0,0 +1,244 @@
+//===- llvm/unittests/ADT/BitFieldsTest.cpp - BitFields unit 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/ADT/Bitfields.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+TEST(BitfieldsTest, Example) {
+  uint8_t storage = 0;
+
+  // Store and retrieve a single bit as bool.
+  using Bool = Bitfield<bool, 0, 1>;
+  setField<Bool>(storage, true);
+  EXPECT_EQ(storage, 0b00000001);
+  //                          ^
+  EXPECT_EQ(getField<Bool>(storage), true);
+
+  // Store and retrieve a 2 bit typed enum.
+  // Note: enum underlying type must be unsigned.
+  enum class SuitEnum : uint8_t { CLUBS, DIAMONDS, HEARTS, SPADES };
+  // Note: enum maximum value needs to be passed in.
+  using Suit = Bitfield<SuitEnum, 1, 2, SuitEnum::SPADES>;
+  setField<Suit>(storage, SuitEnum::HEARTS);
+  EXPECT_EQ(storage, 0b00000101);
+  //                        ^^
+  EXPECT_EQ(getField<Suit>(storage), SuitEnum::HEARTS);
+
+  // Store and retrieve a 5 bit value as unsigned.
+  using Value = Bitfield<unsigned, 3, 5>;
+  setField<Value>(storage, 10);
+  EXPECT_EQ(storage, 0b01010101);
+  //                   ^^^^^
+  EXPECT_EQ(getField<Value>(storage), 10U);
+
+  // Interpret the same 5 bit value as signed.
+  using SignedValue = Bitfield<int, 3, 5>;
+  setField<SignedValue>(storage, -2);
+  EXPECT_EQ(storage, 0b11110101);
+  //                   ^^^^^
+  EXPECT_EQ(getField<SignedValue>(storage), -2);
+
+  // Ability to efficiently test if a field is non zero.
+  EXPECT_TRUE(testField<Value>(storage) != 0U);
+
+  // Alter storage changes value.
+  storage = 0;
+  EXPECT_EQ(getField<Bool>(storage), false);
+  EXPECT_EQ(getField<Suit>(storage), SuitEnum::CLUBS);
+  EXPECT_EQ(getField<Value>(storage), 0U);
+  EXPECT_EQ(getField<SignedValue>(storage), 0);
+
+  storage = 255;
+  EXPECT_EQ(getField<Bool>(storage), true);
+  EXPECT_EQ(getField<Suit>(storage), SuitEnum::SPADES);
+  EXPECT_EQ(getField<Value>(storage), 31U);
+  EXPECT_EQ(getField<SignedValue>(storage), -1);
+}
+
+TEST(BitfieldsTest, FirstBit) {
+  uint8_t storage = 0;
+  using FirstBit = Bitfield<bool, 0, 1>;
+  // Set true
+  setField<FirstBit>(storage, true);
+  EXPECT_EQ(getField<FirstBit>(storage), true);
+  EXPECT_EQ(storage, 0x1ULL);
+  // Set false
+  setField<FirstBit>(storage, false);
+  EXPECT_EQ(getField<FirstBit>(storage), false);
+  EXPECT_EQ(storage, 0x0ULL);
+}
+
+TEST(BitfieldsTest, SecondBit) {
+  uint8_t storage = 0;
+  using SecondBit = Bitfield<bool, 1, 1>;
+  // Set true
+  setField<SecondBit>(storage, true);
+  EXPECT_EQ(getField<SecondBit>(storage), true);
+  EXPECT_EQ(storage, 0x2ULL);
+  // Set false
+  setField<SecondBit>(storage, false);
+  EXPECT_EQ(getField<SecondBit>(storage), false);
+  EXPECT_EQ(storage, 0x0ULL);
+}
+
+TEST(BitfieldsTest, LastBit) {
+  uint8_t storage = 0;
+  using LastBit = Bitfield<bool, 7, 1>;
+  // Set true
+  setField<LastBit>(storage, true);
+  EXPECT_EQ(getField<LastBit>(storage), true);
+  EXPECT_EQ(storage, 0x80ULL);
+  // Set false
+  setField<LastBit>(storage, false);
+  EXPECT_EQ(getField<LastBit>(storage), false);
+  EXPECT_EQ(storage, 0x0ULL);
+}
+
+TEST(BitfieldsTest, LastBitUint64) {
+  uint64_t storage = 0;
+  using LastBit = Bitfield<bool, 63, 1>;
+  // Set true
+  setField<LastBit>(storage, true);
+  EXPECT_EQ(getField<LastBit>(storage), true);
+  EXPECT_EQ(storage, 0x8000000000000000ULL);
+  // Set false
+  setField<LastBit>(storage, false);
+  EXPECT_EQ(getField<LastBit>(storage), false);
+  EXPECT_EQ(storage, 0x0ULL);
+}
+
+TEST(BitfieldsTest, Enum) {
+  enum Enum { Zero = 0, Two = 2, LAST = Two };
+
+  uint8_t storage = 0;
+  using OrderingField = Bitfield<Enum, 1, 2, LAST>;
+  EXPECT_EQ(getField<OrderingField>(storage), Zero);
+  setField<OrderingField>(storage, Two);
+  EXPECT_EQ(getField<OrderingField>(storage), Two);
+  EXPECT_EQ(storage, 0b00000100);
+  // value 2 in             ^^
+}
+
+TEST(BitfieldsTest, EnumClass) {
+  enum class Enum : unsigned { Zero = 0, Two = 2, LAST = Two };
+
+  uint8_t storage = 0;
+  using OrderingField = Bitfield<Enum, 1, 2, Enum::LAST>;
+  EXPECT_EQ(getField<OrderingField>(storage), Enum::Zero);
+  setField<OrderingField>(storage, Enum::Two);
+  EXPECT_EQ(getField<OrderingField>(storage), Enum::Two);
+  EXPECT_EQ(storage, 0b00000100);
+  // value 2 in             ^^
+}
+
+TEST(BitfieldsTest, OneBitSigned) {
+  uint8_t storage = 0;
+  using SignedField = Bitfield<int, 1, 1>;
+  EXPECT_EQ(getField<SignedField>(storage), 0);
+  EXPECT_EQ(storage, 0b00000000);
+  // value 0 in              ^
+  setField<SignedField>(storage, -1);
+  EXPECT_EQ(getField<SignedField>(storage), -1);
+  EXPECT_EQ(storage, 0b00000010);
+  // value 1 in              ^
+}
+
+TEST(BitfieldsTest, TwoBitSigned) {
+  uint8_t storage = 0;
+  using SignedField = Bitfield<int, 1, 2>;
+  EXPECT_EQ(getField<SignedField>(storage), 0);
+  EXPECT_EQ(storage, 0b00000000);
+  // value 0 in             ^^
+  setField<SignedField>(storage, 1);
+  EXPECT_EQ(getField<SignedField>(storage), 1);
+  EXPECT_EQ(storage, 0b00000010);
+  // value 1 in             ^^
+  setField<SignedField>(storage, -1);
+  EXPECT_EQ(getField<SignedField>(storage), -1);
+  EXPECT_EQ(storage, 0b00000110);
+  // value -1 in            ^^
+  setField<SignedField>(storage, -2);
+  EXPECT_EQ(getField<SignedField>(storage), -2);
+  EXPECT_EQ(storage, 0b00000100);
+  // value -2 in            ^^
+}
+
+TEST(BitfieldsTest, isOverlapping) {
+  //    01234567
+  // A: --------
+  // B:    ---
+  // C:  ---
+  // D:     ---
+  using A = Bitfield<unsigned, 0, 8>;
+  using B = Bitfield<unsigned, 3, 3>;
+  using C = Bitfield<unsigned, 1, 3>;
+  using D = Bitfield<unsigned, 4, 3>;
+  EXPECT_TRUE((isOverlapping<A, B>()));
+  EXPECT_TRUE((isOverlapping<A, C>()));
+  EXPECT_TRUE((isOverlapping<A, B>()));
+  EXPECT_TRUE((isOverlapping<A, D>()));
+
+  EXPECT_TRUE((isOverlapping<B, C>()));
+  EXPECT_TRUE((isOverlapping<B, D>()));
+  EXPECT_FALSE((isOverlapping<C, D>()));
+}
+
+TEST(BitfieldsTest, FullUint64) {
+  uint64_t storage = 0;
+  using Value = Bitfield<uint64_t, 0, 64>;
+  setField<Value>(storage, -1ULL);
+  EXPECT_EQ(getField<Value>(storage), -1ULL);
+  setField<Value>(storage, 0ULL);
+  EXPECT_EQ(getField<Value>(storage), 0ULL);
+}
+
+TEST(BitfieldsTest, FullInt64) {
+  uint64_t storage = 0;
+  using Value = Bitfield<int64_t, 0, 64>;
+  setField<Value>(storage, -1);
+  EXPECT_EQ(getField<Value>(storage), -1);
+  setField<Value>(storage, 0);
+  EXPECT_EQ(getField<Value>(storage), 0);
+}
+
+#ifdef EXPECT_DEBUG_DEATH
+
+TEST(BitfieldsTest, ValueTooBigBool) {
+  uint64_t storage = 0;
+  using A = Bitfield<unsigned, 0, 1>;
+  setField<A>(storage, true);
+  setField<A>(storage, false);
+  EXPECT_DEBUG_DEATH(setField<A>(storage, 2), "value is too big");
+}
+
+TEST(BitfieldsTest, ValueTooBigInt) {
+  uint64_t storage = 0;
+  using A = Bitfield<unsigned, 0, 2>;
+  setField<A>(storage, 3);
+  EXPECT_DEBUG_DEATH(setField<A>(storage, 4), "value is too big");
+  EXPECT_DEBUG_DEATH(setField<A>(storage, -1), "value is too big");
+}
+
+TEST(BitfieldsTest, ValueTooBigBounded) {
+  uint8_t storage = 0;
+  using A = Bitfield<int, 1, 2>;
+  setField<A>(storage, 1);
+  setField<A>(storage, 0);
+  setField<A>(storage, -1);
+  setField<A>(storage, -2);
+  EXPECT_DEBUG_DEATH(setField<A>(storage, 2), "value is too big");
+  EXPECT_DEBUG_DEATH(setField<A>(storage, -3), "value is too small");
+}
+
+#endif
+
+} // namespace
\ No newline at end of file
diff --git a/llvm/unittests/ADT/CMakeLists.txt b/llvm/unittests/ADT/CMakeLists.txt
--- a/llvm/unittests/ADT/CMakeLists.txt
+++ b/llvm/unittests/ADT/CMakeLists.txt
@@ -8,6 +8,7 @@
   APIntTest.cpp
   APSIntTest.cpp
   ArrayRefTest.cpp
+  BitFieldsTest.cpp
   BitmaskEnumTest.cpp
   BitVectorTest.cpp
   BreadthFirstIteratorTest.cpp