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,114 @@
+//===-- 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 <cstdint>
+#include <type_traits>
+
+/// Helpers to pack / unpack typed bitfields into an unsigned scalar.
+/// e.g.
+///
+///  uint8_t storage = 0;
+///
+///  // Store and retrieve a single bit as bool.
+///  using Volatile = Bitfield<bool, 0, 1>;
+///  setField<Volatile>(storage, true);
+///  EXPECT_EQ(storage, 0b00000001);
+///  EXPECT_EQ(getField<Volatile>(storage), true);
+///
+///  // Store and retrieve a 2 bit typed enum.
+///  enum class SuitEnum { CLUBS, DIAMONDS, HEARTS, SPADES };
+///  using Suit = Bitfield<SuitEnum, 1, 2>;
+///  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);
+///
+///  // Alter storage changes value.
+///  storage = 0;
+///  EXPECT_EQ(getField<Volatile>(storage), false);
+///  EXPECT_EQ(getField<Suit>(storage), SuitEnum::CLUBS);
+///  EXPECT_EQ(getField<Value>(storage), 0U);
+///
+///  storage = 255;
+///  EXPECT_EQ(getField<Volatile>(storage), true);
+///  EXPECT_EQ(getField<Suit>(storage), SuitEnum::SPADES);
+///  EXPECT_EQ(getField<Value>(storage), 31U);
+///
+///  // Ability to efficiently test if a field is non zero.
+///  EXPECT_NE(testField<Value>(storage), 0U);
+
+namespace llvm {
+
+/// 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.
+template <typename Type, unsigned Offset, unsigned Size> struct Bitfield {
+  using type = Type;
+  static_assert(std::is_unsigned<type>::value || std::is_enum<type>::value,
+                "Type must be unsigned or enum");
+  static constexpr unsigned offset = Offset;
+  static constexpr unsigned size = Size;
+  static_assert(size > 0, "Size must be non zero");
+  static_assert((offset + size) <= 64, "Data must fit in 64 bits");
+  static constexpr uint64_t max_value = (1ULL << size) - 1ULL;
+  static constexpr uint64_t mask = max_value << offset;
+};
+
+/// Unpacks the field from the packed value.
+template <typename Bitfield, typename T>
+static typename Bitfield::type getField(T packed) {
+  static_assert(std::is_unsigned<T>(), "storage must be unsigned");
+  static_assert(sizeof(T) <= sizeof(uint64_t),
+                "T must not exceed uint64_t size");
+  const T masked = packed & Bitfield::mask;
+  const T shifted = masked >> Bitfield::offset;
+  return static_cast<typename Bitfield::type>(shifted);
+}
+
+/// Return a non zero value if the field is non zero.
+/// It saves a shift operation compared to `getField`.
+template <typename Bitfield, typename T> static T testField(T packed) {
+  static_assert(std::is_unsigned<T>(), "storage must be unsigned");
+  static_assert(sizeof(T) <= sizeof(uint64_t),
+                "T must not exceed uint64_t size");
+  return packed & Bitfield::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 T>
+static void setField(T &packed, typename Bitfield::type value) {
+  static_assert(std::is_unsigned<T>(), "storage must be unsigned");
+  static_assert(sizeof(T) <= sizeof(uint64_t),
+                "T must not exceed uint64_t size");
+  assert(static_cast<uint64_t>(value) <= Bitfield::max_value &&
+         "value is too big");
+  packed &= ~Bitfield::mask;
+  packed |= T(value) << Bitfield::offset;
+}
+
+} // 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,141 @@
+//===- 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 Volatile = Bitfield<bool, 0, 1>;
+  setField<Volatile>(storage, true);
+  EXPECT_EQ(storage, 0b00000001);
+  EXPECT_EQ(getField<Volatile>(storage), true);
+
+  // Store and retrieve a 2 bit typed enum.
+  enum class SuitEnum { CLUBS, DIAMONDS, HEARTS, SPADES };
+  using Suit = Bitfield<SuitEnum, 1, 2>;
+  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);
+
+  // Alter storage changes value.
+  storage = 0;
+  EXPECT_EQ(getField<Volatile>(storage), false);
+  EXPECT_EQ(getField<Suit>(storage), SuitEnum::CLUBS);
+  EXPECT_EQ(getField<Value>(storage), 0U);
+
+  storage = 255;
+  EXPECT_EQ(getField<Volatile>(storage), true);
+  EXPECT_EQ(getField<Suit>(storage), SuitEnum::SPADES);
+  EXPECT_EQ(getField<Value>(storage), 31U);
+
+  // Ability to efficiently test if a field is non zero.
+  EXPECT_NE(testField<Value>(storage), 0U);
+}
+
+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);
+}
+
+enum class Ordering {
+  Not = 0,
+  Unordered = 1,
+  Monotonic = 2,
+};
+
+TEST(BitfieldsTest, EnumClass) {
+  uint8_t storage = 0;
+  using OrderingField = Bitfield<Ordering, 1, 2>;
+  EXPECT_EQ(getField<OrderingField>(storage), Ordering::Not);
+  setField<OrderingField>(storage, Ordering::Monotonic);
+  EXPECT_EQ(getField<OrderingField>(storage), Ordering::Monotonic);
+  EXPECT_EQ(storage, 0b00000100);
+  // value 2 in             ^^
+}
+
+#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");
+}
+
+#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