[IR] Refactor SubclassData

[ekatz]

Summary

A new implementation of the Subclass Data exposed from llvm::Value, which simplifies the process of adding new data/flags into the llvm::Value::SubclassData.

In detail, the new implementation offers the following new features:

• static assert - that the declared accumulated bitfields do not exceed the underlying subclass data size (note that int the New implementation it is automatically added on declaration)
• runtime assert - that a new value set, fits into the the bitfield (without truncation).
• typed - as opposed to using a representative type (like int) and then cast to the actual required type (like bool or enum). Typed (ordinary) bitfields cannot be implemented correctly in MSVC, as the types of all the bitfields must be of the same type. Using typed bitfields also saves us the need to synchronize the use of unsigned/signed int with the actual type needed.
• declare (a bitfield) in a single line - as opposed to the need to declare helpers or somekind, like enum (manually).
• clean bitfields - without exposing a bit manipulation enum.
• automatic inheritance of unused bits - no need to get offset from super (manually).
• automatic calculation of unused bits - changing a single bitfield doesn't require any other change, but the actual bitfield itself (as opposed to changing also the sum of the bit count used by the class, in an enum - for exmple).
• implicit reference to superclass - as opposed to the need to use the base class' info explicitly.
• no need to know anything about any of the base classes.

The core of the change is present in the 2 new files: BitField.h and SubclassData.h (while the other changed files are just refactored to use the new implementation).

An example of the run-time benefits (to add to the compile-time benefits mentioned above):
By using the new implementation, I have managed to move the SSID field (that some Instructions have) into the Subclass Data of the Instructions, and in turn reduce the size of those instructions by 8 bytes.

[ekatz]

Ping

[ekatz]

Ping

[rnk]

I feel like this is creating too much unnecessary abstraction. I think we can use simple techniques, like unions, as I did here in this uncommitted patch:
https://reviews.llvm.org/D51664#C1373737NL442
Even better, we can do that incrementally, without many changes to the get/set value subclass data APIs.

[ekatz]

In D72068#1822503, @rnk wrote:

I feel like this is creating too much unnecessary abstraction. I think we can use simple techniques, like unions, as I did here in this uncommitted patch:
https://reviews.llvm.org/D51664#C1373737NL442
Even better, we can do that incrementally, without many changes to the get/set value subclass data APIs.

I do not think it is unnecessary, as we gain so much from it, right away, and also a lot of potential for future improvements.
I think it's worth the benefits listed in the summary.

This may be a large change, but if you look closely, it is not that big of a deal - it is pretty intuitive.
The change is large only due to the large number of subclass data flags.
I can always separate it to 2 changes (or more if possible).

[ekatz]

Ping

[ekatz]

Ping

[ekatz]

Ping

[ekatz]

Ping

[ekatz]

Ping

[rnk]

I'm still basically not in favor of this. If another contributor thinks it's a great idea, I wouldn't go so far as to block this change, but I don't plan to do any further review.

[ekatz]

In D72068#1889825, @rnk wrote:

I'm still basically not in favor of this. If another contributor thinks it's a great idea, I wouldn't go so far as to block this change, but I don't plan to do any further review.

Fair enough, I respect your opinion.
However, I still think it is a very welcoming change (for the many reasons listed in the "summary"), and I hope other reviewers will see the benefits as I see them, and approve this change.

[dexonsmith]

In D72068#1905933, @ekatz wrote:

In D72068#1889825, @rnk wrote:

I'm still basically not in favor of this. If another contributor thinks it's a great idea, I wouldn't go so far as to block this change, but I don't plan to do any further review.

Fair enough, I respect your opinion.
However, I still think it is a very welcoming change (for the many reasons listed in the "summary"), and I hope other reviewers will see the benefits as I see them, and approve this change.

Given the contention around direction, I would suggest that you seek consensus via an RFC on llvm-dev before pinging the patch any further.

[ekatz]

In D72068#1906010, @dexonsmith wrote:

Given the contention around direction, I would suggest that you seek consensus via an RFC on llvm-dev before pinging the patch any further.

It is the first thing that I did, but I was asked to post the patch for review. I agree that there should have been more discussion in the mail, but it seems stranger (and with not much response) to ping a mail thread.
Please refer to http://lists.llvm.org/pipermail/llvm-dev/2020-January/138710.html for further details.

[dexonsmith]

In D72068#1906074, @ekatz wrote:

In D72068#1906010, @dexonsmith wrote:

Given the contention around direction, I would suggest that you seek consensus via an RFC on llvm-dev before pinging the patch any further.

It is the first thing that I did, but I was asked to post the patch for review. I agree that there should have been more discussion in the mail, but it seems stranger (and with not much response) to ping a mail thread.
Please refer to http://lists.llvm.org/pipermail/llvm-dev/2020-January/138710.html for further details.

I think the RFC is the right thing to ping, if you're going to proceed.

llvm/include/llvm/ADT/BitField.h

+//===- llvm/ADT/BitField.h - Safe Portable Bit-field ------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_BITFIELD_H
+#define LLVM_ADT_BITFIELD_H
+
+#include "llvm/ADT/STLExtras.h"
+
+namespace llvm {
+
+template <unsigned Offset, unsigned Size, class T,
+          typename = typename std::enable_if<(Offset + Size) <= 64 &&
+                                             (std::is_integral<T>::value ||
+                                              std::is_enum<T>::value)>::type>
+class BitField {
+  template <class T2>
+  using enable_if_underlying_integral_t =
+      typename std::enable_if<std::is_integral<T2>::value ||
+                              std::is_enum<T2>::value>::type;
+
+  static constexpr bool is_bool_v = std::is_same<T, bool>::value;
+
+  using TVal = typename std::conditional<
+      std::is_enum<T>::value, std::underlying_type<T>,
+      std::conditional<is_bool_v, uint8_t, T>>::type::type;
+
+  static constexpr bool is_signed_v = std::is_signed<TVal>::value;
+
+  using TInt = typename smallest_integral<Offset + Size, is_signed_v>::type;
+
+  using TSInt = typename std::make_signed<TInt>::type;
+  using TUInt = typename std::make_unsigned<TInt>::type;
+
+  using TNative = typename std::conditional<
+      sizeof(TInt) < sizeof(int),
+      typename std::conditional<is_signed_v, signed, unsigned>::type,
+      TInt>::type;
+
+  using TSNative = typename std::make_signed<TNative>::type;
+  using TUNative = typename std::make_unsigned<TNative>::type;
+
+  using TCast = typename std::conditional<is_bool_v, uint8_t, T>::type;
+
+  static constexpr TUInt Mask = bit_maskof<BitField>();
+  TInt Value;
+
+  template <class T2> static void verify(T2 V) {
+    if (Size < bit_sizeof(V)) {
+      if (is_signed_v) {
+        assert(int64_t(V) >= (int64_t(-1) << (Size - 1)) &&
+               int64_t(V) <= ~(int64_t(-1) << (Size - 1)) &&
+               "Value does not fit into bit-field!");
+      } else
+        assert(uint64_t(V) <= ~(~uint64_t(0) << Size) &&
+               "Value does not fit into bit-field!");
+    }
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &set(TNative N) {
+    Value = TInt((TUNative(Value) & ~TUNative(Mask)) |
+                 ((TUNative(N) << Offset) & TUNative(Mask)));
+    return *this;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE static TUNative get(TUNative V) {
+    return (V & TUNative(Mask)) >> Offset;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE static TSNative get(TSNative V) {
+    return (V << (bit_sizeof<TSNative>() - (Offset + Size))) >>
+           (bit_sizeof<TSNative>() - Size);
+  }
+
+public:
+  template <class T2, typename = enable_if_underlying_integral_t<T2>>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator=(T2 RHS) {
+    verify(RHS);
+    return set(TNative(RHS));
+  }
+
+  template <class T2, typename = enable_if_underlying_integral_t<T2>>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator+=(T2 RHS) {
+    TUNative N = TUNative(RHS) << Offset;
+    TUNative V = TUNative(Value);
+    TUNative Rest = V & ~TUNative(Mask);
+    Value = TInt(((V + N) & TUNative(Mask)) | Rest);
+    return *this;
+  }
+
+  template <class T2, typename = enable_if_underlying_integral_t<T2>>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator-=(T2 RHS) {
+    TUNative N = TUNative(RHS) << Offset;
+    TUNative V = TUNative(Value);
+    TUNative Rest = V & ~TUNative(Mask);
+    Value = TInt(((V - N) & TUNative(Mask)) | Rest);
+    return *this;
+  }
+
+  template <class T2, typename = enable_if_underlying_integral_t<T2>>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator*=(T2 RHS) {
+    TUNative N = TUNative(RHS);
+    TUNative V = TUNative(Value);
+    TUNative Rest = V & ~TUNative(Mask);
+    Value = TInt(((V * N) & TUNative(Mask)) | Rest);
+    return *this;
+  }
+
+  template <class T2, typename = enable_if_underlying_integral_t<T2>>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator/=(T2 RHS) {
+    TUNative N = TUNative(RHS);
+    TUNative V = TUNative(Value);
+    TUNative Rest = V & ~TUNative(Mask);
+    Value = TInt(((V / N) & TUNative(Mask)) | Rest);
+    return *this;
+  }
+
+  template <class T2, typename = enable_if_underlying_integral_t<T2>>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator%=(T2 RHS) {
+    return set(*this % TNative(RHS));
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField operator~() const {
+    return {TInt(TUNative(Value) ^ TUNative(Mask))};
+  }
+
+  template <class T2, typename = enable_if_underlying_integral_t<T2>>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator&=(T2 RHS) {
+    TUNative N = (TUNative(RHS) << Offset) | ~TUNative(Mask);
+    Value = TInt(TUNative(Value) & N);
+    return *this;
+  }
+
+  template <class T2, typename = enable_if_underlying_integral_t<T2>>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator|=(T2 RHS) {
+    TUNative N = (TUNative(RHS) << Offset) & TUNative(Mask);
+    Value = TInt(TUNative(Value) | N);
+    return *this;
+  }
+
+  template <class T2, typename = enable_if_underlying_integral_t<T2>>
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator^=(T2 RHS) {
+    TUNative N = (TUNative(RHS) << Offset) & TUNative(Mask);
+    Value = TInt(TUNative(Value) ^ N);
+    return *this;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator<<=(size_t BitCount) {
+    TUNative V = TUNative(Value);
+    TUNative Rest = V & ~TUNative(Mask);
+    Value = TInt((((V & TUNative(Mask)) << BitCount) & TUNative(Mask)) | Rest);
+    return *this;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator>>=(size_t BitCount) {
+    TUNative V = TUNative(Value);
+    TUNative Rest = V & ~TUNative(Mask);
+    Value = TInt((((V & TUNative(Mask)) >> BitCount) & TUNative(Mask)) | Rest);
+    return *this;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE operator TCast() const {
+    return TCast(get(TNative(Value)));
+  }
+  LLVM_ATTRIBUTE_ALWAYS_INLINE explicit operator bool() const {
+    return Value & TInt(Mask);
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator++() { return *this += 1; }
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField operator++(int) {
+    BitField Tmp = *this;
+    ++*this;
+    return Tmp;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator--() { return *this -= 1; }
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField operator--(int) {
+    BitField Tmp = *this;
+    --*this;
+    return Tmp;
+  }
+};
+
+template <unsigned Offset> class BitField<Offset, 1, bool, void> {
+  using TInt = typename smallest_integral<Offset + 1, false>::type;
+
+  using TNative = typename std::conditional<sizeof(TInt) < sizeof(int),
+                                            unsigned, TInt>::type;
+
+  static constexpr TInt Mask = bit_maskof<BitField>();
+  TInt Value;
+
+public:
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator=(bool RHS) {
+    Value = TInt((TNative(Value) & ~TNative(Mask)) | (TNative(RHS) << Offset));
+    return *this;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator+=(bool RHS) {
+    return operator|=(RHS);
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator-=(bool RHS) {
+    return operator^=(RHS);
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator*=(bool RHS) {
+    return operator&=(RHS);
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField operator~() const {
+    return {TInt(TNative(Value) ^ TNative(Mask))};
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator&=(bool RHS) {
+    Value = TInt(TNative(Value) & (TNative(RHS) << Offset));
+    return *this;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator|=(bool RHS) {
+    Value = TInt(TNative(Value) | (TNative(RHS) << Offset));
+    return *this;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE BitField &operator^=(bool RHS) {
+    Value = TInt(TNative(Value) ^ (TNative(RHS) << Offset));
+    return *this;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE bool operator==(bool RHS) const {
+    return static_cast<bool>(*this) == RHS;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE bool operator!=(bool RHS) const {
+    return static_cast<bool>(*this) != RHS;
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE explicit operator bool() const {
+    return Value & TInt(Mask);
+  }
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE operator uint8_t() const {
+    return uint8_t((TNative(Value) >> Offset) & TNative(1));
+  }
+};
+
+
+template <unsigned Offset, unsigned Sz, class T>
+struct TypeBitTraits<BitField<Offset, Sz, T>> {
+  static constexpr unsigned Low = Offset;
+  static constexpr unsigned Count = Sz;
+};
+
+
+#define BEGIN_PACKED_BITFIELDS(Bits)                                           \
+  union {                                                                      \
+    ::llvm::smallest_integral<Bits>::type PackedBitfieldsData = 0;             \
+    ::llvm::BitField<0, ::llvm::bit_sizeof<decltype(PackedBitfieldsData)>()
+
+#define ADD_PACKED_BITFIELD(Type, Bits, Name)                                  \
+        * 0 + Bits, Type > Name;                                               \
+  ::llvm::BitField<(::llvm::bit_offsetof<decltype(Name)>() +                   \
+                    ::llvm::bit_sizeof<decltype(Name)>()),                     \
+      (::llvm::bit_sizeof<decltype(PackedBitfieldsData)>() -                   \
+       (::llvm::bit_offsetof<decltype(Name)>() +                               \
+        ::llvm::bit_sizeof<decltype(Name)>()))
+
+#define END_PACKED_BITFIELDS()                                                 \
+        , decltype(PackedBitfieldsData)> SubclassData;                         \
+  }
+
+} // end namespace llvm
+
+#endif // LLVM_ADT_BITFIELD_H

llvm/include/llvm/ADT/STLExtras.h

 };
 
 template <typename T, typename U, typename... Ts>
 struct are_base_of<T, U, Ts...> {
   static const bool value =
       std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
 };
 
+template <typename T> struct TypeBitTraits {
+  static constexpr unsigned Low = 0;
+  static constexpr unsigned Count = sizeof(T) * CHAR_BIT;
+};
+
+template <typename T> constexpr inline size_t bit_sizeof() {
+  return TypeBitTraits<T>::Count;
+}
+template <typename T> constexpr inline size_t bit_sizeof(const T &) {
+  return bit_sizeof<T>();
+}
+
+template <typename T> constexpr inline size_t bit_offsetof() {
+  return TypeBitTraits<T>::Low;
+}
+template <typename T> constexpr inline size_t bit_offsetof(const T &) {
+  return bit_offsetof<T>();
+}
+
+template <typename T>
+constexpr inline
+    typename smallest_integral<bit_offsetof<T>() + bit_sizeof<T>()>::type
+    bit_maskof() {
+  constexpr
+      typename smallest_integral<bit_offsetof<T>() + bit_sizeof<T>()>::type
+          One = 1;
+  return ((One << bit_sizeof<T>()) - One) << bit_offsetof<T>();
+}
+template <typename T>
+constexpr inline
+    typename smallest_integral<bit_offsetof<T>() + bit_sizeof<T>()>::type
+    bit_maskof(const T &) {
+  return bit_maskof<T>();
+}
+
 //===----------------------------------------------------------------------===//
 //     Extra additions for arrays
 //===----------------------------------------------------------------------===//
 
 /// Find the length of an array.
 template <class T, std::size_t N>
 constexpr inline size_t array_lengthof(T (&)[N]) {
   return N;

llvm/include/llvm/ADT/SubclassData.h

+//===-- llvm/ADT/SubclassData.h ---------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ADT_SUBCLASSDATA_H
+#define LLVM_ADT_SUBCLASSDATA_H
+
+#include "llvm/ADT/BitField.h"
+
+#define DECLARE_SUBCLASS_DATA(Class)                                           \
+  struct Class##SubclassDataImpl {                                             \
+  protected:                                                                   \
+    struct FINAL_LIMITS {                                                      \
+      static constexpr int Begin =                                             \
+          ::llvm::bit_offsetof<decltype(Class::SubclassData)>();               \
+      static constexpr int End =                                               \
+          Begin + ::llvm::bit_sizeof<decltype(Class::SubclassData)>();         \
+      static_assert(Begin <= End, "Invalid " #Class " Subclass Data Size!");   \
+    };                                                                         \
+  };                                                                           \
+  LLVM_ATTRIBUTE_ALWAYS_INLINE auto &Class##SubclassData() {                   \
+    return reinterpret_cast<Class##SubclassDataImpl &>(SubclassData);          \
+  }                                                                            \
+  LLVM_ATTRIBUTE_ALWAYS_INLINE auto &Class##SubclassData() const {             \
+    return reinterpret_cast<const Class##SubclassDataImpl &>(SubclassData);    \
+  }
+
+
+#define BEGIN_SUBCLASS_DATA(Owner, Class)                                      \
+  using Owner##SubclassDataBase = Owner##SubclassDataImpl;                     \
+  struct Owner##SubclassDataImpl : private Owner##SubclassDataBase {           \
+    union Fields {                                                             \
+    private:                                                                   \
+      friend struct Class::Owner##SubclassDataImpl;                            \
+      typedef Class::Owner##SubclassDataBase::FINAL_LIMITS
+
+
+#define ADD_SUBCLASS_BITFIELD(Owner, Type, Bits, Name)                         \
+      PREV_##Name;                                                             \
+                                                                               \
+    public:                                                                    \
+      llvm::BitField<                                                          \
+          ((Bits) < 0 ? (PREV_##Name::End + Bits) : PREV_##Name::Begin),       \
+          ((Bits) < 0 ? -(Bits) : (Bits)), Type>                               \
+          Name;                                                                \
+                                                                               \
+    private:                                                                   \
+      typedef struct NEXT_##Name {                                             \
+        static constexpr int Begin =                                           \
+            PREV_##Name::Begin + ((Bits) < 0 ? 0 : (Bits));                    \
+                                                                               \
+        static constexpr int End =                                             \
+            PREV_##Name::End + ((Bits) < 0 ? (Bits) : 0);                      \
+                                                                               \
+        static_assert(Begin <= End, "Not enough bits for field " #Name " in "  \
+                                    #Owner " Subclass Data!");                 \
+      }
+
+
+#define END_SUBCLASS_DATA(Owner)                                               \
+      END_LIMITS;                                                              \
+    };                                                                         \
+  protected:                                                                   \
+    using FINAL_LIMITS = Fields::END_LIMITS;                                   \
+  };                                                                           \
+  LLVM_ATTRIBUTE_ALWAYS_INLINE auto &Owner##SubclassData() {                   \
+    return reinterpret_cast<Owner##SubclassDataImpl::Fields &>(                \
+        Owner::Owner##SubclassData());                                         \
+  }                                                                            \
+  LLVM_ATTRIBUTE_ALWAYS_INLINE auto &Owner##SubclassData() const {             \
+    return reinterpret_cast<const Owner##SubclassDataImpl::Fields &>(          \
+        Owner::Owner##SubclassData());                                         \
+  }
+
+#define TYPEOF_SUBCLASS_BITFIELD(Owner, Name)                                  \
+  decltype(Owner##SubclassDataImpl::Fields::Name)
+
+#endif // LLVM_ADT_SUBCLASSDATA_H

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum RMWOperations {
   RMW_MIN = 8,
   RMW_UMAX = 9,
   RMW_UMIN = 10,
   RMW_FADD = 11,
   RMW_FSUB = 12
 };
 
 /// OverflowingBinaryOperatorOptionalFlags - Flags for serializing
-/// OverflowingBinaryOperator's SubclassOptionalData contents.
+/// OverflowingBinaryOperator's Subclass Data contents.
 enum OverflowingBinaryOperatorOptionalFlags {
   OBO_NO_UNSIGNED_WRAP = 0,
   OBO_NO_SIGNED_WRAP = 1
 };
 
 /// FastMath Flags
 /// This is a fixed layout derived from the bitcode emitted by LLVM 5.0
 /// intended to decouple the in-memory representation from the serialization.
 enum FastMathMap {
   UnsafeAlgebra   = (1 << 0), // Legacy
   NoNaNs          = (1 << 1),
   NoInfs          = (1 << 2),
   NoSignedZeros   = (1 << 3),
   AllowReciprocal = (1 << 4),
   AllowContract   = (1 << 5),
   ApproxFunc      = (1 << 6),
   AllowReassoc    = (1 << 7)
 };
 
 /// PossiblyExactOperatorOptionalFlags - Flags for serializing
-/// PossiblyExactOperator's SubclassOptionalData contents.
+/// PossiblyExactOperator's Subclass Data contents.
 enum PossiblyExactOperatorOptionalFlags { PEO_EXACT = 0 };
 
 /// Encoded AtomicOrdering values.
 enum AtomicOrderingCodes {
   ORDERING_NOTATOMIC = 0,
   ORDERING_UNORDERED = 1,
   ORDERING_MONOTONIC = 2,
   ORDERING_ACQUIRE = 3,

llvm/include/llvm/IR/BasicBlock.h

 
 private:
   friend class BlockAddress;
   friend class SymbolTableListTraits<BasicBlock>;
 
   InstListType InstList;
   Function *Parent;
 
+  BEGIN_VALUE_SUBCLASS_DATA(BasicBlock)
+    ADD_VALUE_SUBCLASS_BITFIELD(int,        8, BlockAddressRefCount)
+    ADD_VALUE_SUBCLASS_BITFIELD(unsigned, -32, Ordinal)
+    END_VALUE_SUBCLASS_DATA()
+
   void setParent(Function *parent);
 
   /// Constructor.
   ///
   /// If the function parameter is specified, the basic block is automatically
   /// inserted at either the end of the function (if InsertBefore is null), or
   /// before the specified basic block.
   explicit BasicBlock(LLVMContext &C, const Twine &Name = "",
public:
   /// keeping loop information consistent, use the SplitBlock utility function.
   BasicBlock *splitBasicBlock(iterator I, const Twine &BBName = "");
   BasicBlock *splitBasicBlock(Instruction *I, const Twine &BBName = "") {
     return splitBasicBlock(I->getIterator(), BBName);
   }
 
   /// Returns true if there are any uses of this basic block other than
   /// direct branches, switches, etc. to it.
-  bool hasAddressTaken() const { return getSubclassDataFromValue() != 0; }
+  bool hasAddressTaken() const {
+    return ValueSubclassData().BlockAddressRefCount != 0;
+  }
 
   /// Update all phi nodes in this basic block to refer to basic block \p New
   /// instead of basic block \p Old.
   void replacePhiUsesWith(BasicBlock *Old, BasicBlock *New);
 
   /// Update all phi nodes in this basic block's successors to refer to basic
   /// block \p New instead of basic block \p Old.
   void replaceSuccessorsPhiUsesWith(BasicBlock *Old, BasicBlock *New);

 
 private:
   /// Increment the internal refcount of the number of BlockAddresses
   /// referencing this BasicBlock by \p Amt.
   ///
   /// This is almost always 0, sometimes one possibly, but almost never 2, and
   /// inconceivably 3 or more.
   void AdjustBlockAddressRefCount(int Amt) {
-    setValueSubclassData(getSubclassDataFromValue()+Amt);
-    assert((int)(signed char)getSubclassDataFromValue() >= 0 &&
+    ValueSubclassData().BlockAddressRefCount += Amt;
+    assert(ValueSubclassData().BlockAddressRefCount >= 0 &&
            "Refcount wrap-around");
   }
-
-  /// Shadow Value::setValueSubclassData with a private forwarding method so
-  /// that any future subclasses cannot accidentally use it.
-  void setValueSubclassData(unsigned short D) {
-    Value::setValueSubclassData(D);
-  }
 };
 
 // Create wrappers for C Binding types (see CBindingWrapping.h).
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(BasicBlock, LLVMBasicBlockRef)
 
 /// Advance \p It while it points to a debug instruction and return the result.
 /// This assumes that \p It is not at the end of a block.
 BasicBlock::iterator skipDebugIntrinsics(BasicBlock::iterator It);
 
 } // end namespace llvm
 
 #endif // LLVM_IR_BASICBLOCK_H

llvm/include/llvm/IR/Constants.h

 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value)
 
 //===----------------------------------------------------------------------===//
 /// A constant value that is initialized with an expression using
 /// other constant values.
 ///
 /// This class uses the standard Instruction opcodes to define the various
 /// constant expressions.  The Opcode field for the ConstantExpr class is
-/// maintained in the Value::SubclassData field.
+/// maintained in the ValueSubclassData::Opcode field.
 class ConstantExpr : public Constant {
   friend struct ConstantExprKeyType;
   friend class Constant;
 
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
 
 protected:
+  BEGIN_VALUE_SUBCLASS_DATA(ConstantExpr)
+    ADD_VALUE_SUBCLASS_BITFIELD(unsigned,  8, Opcode)
+    ADD_VALUE_SUBCLASS_OPTIONALDATA()
+    END_VALUE_SUBCLASS_DATA()
+
   ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
       : Constant(ty, ConstantExprVal, Ops, NumOps) {
-    // Operation type (an Instruction opcode) is stored as the SubclassData.
-    setValueSubclassData(Opcode);
+    // Operation type (an Instruction opcode).
+    ValueSubclassData().Opcode = Opcode;
   }
 
 public:
   // Static methods to construct a ConstantExpr of different kinds.  Note that
   // these methods may return a object that is not an instance of the
   // ConstantExpr class, because they will attempt to fold the constant
   // expression into something simpler if possible.
 
static Constant *getShuffleVector(Constant *V1, Constant *V2, Constant *Mask,
                                     Type *OnlyIfReducedTy = nullptr);
   static Constant *getExtractValue(Constant *Agg, ArrayRef<unsigned> Idxs,
                                    Type *OnlyIfReducedTy = nullptr);
   static Constant *getInsertValue(Constant *Agg, Constant *Val,
                                   ArrayRef<unsigned> Idxs,
                                   Type *OnlyIfReducedTy = nullptr);
 
   /// Return the opcode at the root of this constant expression
-  unsigned getOpcode() const { return getSubclassDataFromValue(); }
+  unsigned getOpcode() const { return ValueSubclassData().Opcode; }
 
   /// Return the ICMP or FCMP predicate value. Assert if this is not an ICMP or
   /// FCMP constant expression.
   unsigned getPredicate() const;
 
   /// Assert that this is an insertvalue or exactvalue
   /// expression and return the list of indices.
   ArrayRef<unsigned> getIndices() const;
public:
   /// implementation details of ConstantExpr outside of Constants.cpp, which
   /// would make it harder to remove ConstantExprs altogether.
   Instruction *getAsInstruction() const;
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Value *V) {
     return V->getValueID() == ConstantExprVal;
   }
-
-private:
-  // Shadow Value::setValueSubclassData with a private forwarding method so that
-  // subclasses cannot accidentally use it.
-  void setValueSubclassData(unsigned short D) {
-    Value::setValueSubclassData(D);
-  }
 };
 
 template <>
 struct OperandTraits<ConstantExpr> :
   public VariadicOperandTraits<ConstantExpr, 1> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ConstantExpr, Constant)

llvm/include/llvm/IR/DerivedTypes.h

 
 /// Class to represent integer types. Note that this class is also used to
 /// represent the built-in integer types: Int1Ty, Int8Ty, Int16Ty, Int32Ty and
 /// Int64Ty.
 /// Integer representation type
 class IntegerType : public Type {
   friend class LLVMContextImpl;
 
+  BEGIN_TYPE_SUBCLASS_DATA(IntegerType)
+    ADD_TYPE_SUBCLASS_BITFIELD(unsigned, 24, NumBits)
+    END_TYPE_SUBCLASS_DATA()
+
 protected:
   explicit IntegerType(LLVMContext &C, unsigned NumBits) : Type(C, IntegerTyID){
-    setSubclassData(NumBits);
+    TypeSubclassData().NumBits = NumBits;
   }
 
 public:
   /// This enum is just used to hold constants we need for IntegerType.
   enum {
     MIN_INT_BITS = 1,        ///< Minimum number of bits that can be specified
     MAX_INT_BITS = (1<<24)-1 ///< Maximum number of bits that can be specified
-      ///< Note that bit width is stored in the Type classes SubclassData field
+      ///< Note that bit width is stored in the TypeSubclassData::NumBits field
       ///< which has 24 bits. This yields a maximum bit width of 16,777,215
       ///< bits.
   };
 
   /// This static method is the primary way of constructing an IntegerType.
   /// If an IntegerType with the same NumBits value was previously instantiated,
   /// that instance will be returned. Otherwise a new one will be created. Only
   /// one instance with a given NumBits value is ever created.
   /// Get or create an IntegerType instance.
   static IntegerType *get(LLVMContext &C, unsigned NumBits);
 
   /// Returns type twice as wide the input type.
   IntegerType *getExtendedType() const {
     return Type::getIntNTy(getContext(), 2 * getScalarSizeInBits());
   }
 
   /// Get the number of bits in this IntegerType
-  unsigned getBitWidth() const { return getSubclassData(); }
+  unsigned getBitWidth() const { return TypeSubclassData().NumBits; }
 
   /// Return a bitmask with ones set for all of the bits that can be set by an
   /// unsigned version of this type. This is 0xFF for i8, 0xFFFF for i16, etc.
   uint64_t getBitMask() const {
     return ~uint64_t(0UL) >> (64-getBitWidth());
   }
 
   /// Return a uint64_t with just the most significant bit set (the sign bit, if
unsigned Type::getIntegerBitWidth() const {
   return cast<IntegerType>(this)->getBitWidth();
 }
 
 /// Class to represent function types
 ///
 class FunctionType : public Type {
   FunctionType(Type *Result, ArrayRef<Type*> Params, bool IsVarArgs);
 
+  BEGIN_TYPE_SUBCLASS_DATA(FunctionType)
+    ADD_TYPE_SUBCLASS_BITFIELD(bool, 1, IsVarArgs)
+    END_TYPE_SUBCLASS_DATA()
+
 public:
   FunctionType(const FunctionType &) = delete;
   FunctionType &operator=(const FunctionType &) = delete;
 
   /// This static method is the primary way of constructing a FunctionType.
   static FunctionType *get(Type *Result,
                            ArrayRef<Type*> Params, bool isVarArg);
 
   /// Create a FunctionType taking no parameters.
   static FunctionType *get(Type *Result, bool isVarArg);
 
   /// Return true if the specified type is valid as a return type.
   static bool isValidReturnType(Type *RetTy);
 
   /// Return true if the specified type is valid as an argument type.
   static bool isValidArgumentType(Type *ArgTy);
 
-  bool isVarArg() const { return getSubclassData()!=0; }
+  bool isVarArg() const { return TypeSubclassData().IsVarArgs; }
   Type *getReturnType() const { return ContainedTys[0]; }
 
   using param_iterator = Type::subtype_iterator;
 
   param_iterator param_begin() const { return ContainedTys + 1; }
   param_iterator param_end() const { return &ContainedTys[NumContainedTys]; }
   ArrayRef<Type *> params() const {
     return makeArrayRef(param_begin(), param_end());

 /// laid out in memory consecutively with the elements directly one after the
 /// other (if the struct is packed) or (if not packed) with padding between the
 /// elements as defined by DataLayout (which is required to match what the code
 /// generator for a target expects).
 ///
 class StructType : public CompositeType {
   StructType(LLVMContext &C) : CompositeType(C, StructTyID) {}
 
-  enum {
-    /// This is the contents of the SubClassData field.
-    SCDB_HasBody = 1,
-    SCDB_Packed = 2,
-    SCDB_IsLiteral = 4,
-    SCDB_IsSized = 8
-  };
+  BEGIN_TYPE_SUBCLASS_DATA(StructType)
+    ADD_TYPE_SUBCLASS_BITFIELD(bool, 1, HasBody)
+    ADD_TYPE_SUBCLASS_BITFIELD(bool, 1, Packed)
+    ADD_TYPE_SUBCLASS_BITFIELD(bool, 1, IsLiteral)
+    ADD_TYPE_SUBCLASS_BITFIELD(bool, 1, IsSized)
+    END_TYPE_SUBCLASS_DATA()
 
   /// For a named struct that actually has a name, this is a pointer to the
   /// symbol table entry (maintained by LLVMContext) for the struct.
   /// This is null if the type is an literal struct or if it is a identified
   /// type that has an empty name.
   void *SymbolTableEntry = nullptr;
 
 public:
static typename std::enable_if<are_base_of<Type, Tys...>::value,
                                  StructType *>::type
   get(Type *elt1, Tys *... elts) {
     assert(elt1 && "Cannot create a struct type with no elements with this");
     LLVMContext &Ctx = elt1->getContext();
     SmallVector<llvm::Type *, 8> StructFields({elt1, elts...});
     return llvm::StructType::get(Ctx, StructFields);
   }
 
-  bool isPacked() const { return (getSubclassData() & SCDB_Packed) != 0; }
+  bool isPacked() const { return TypeSubclassData().Packed; }
 
   /// Return true if this type is uniqued by structural equivalence, false if it
   /// is a struct definition.
-  bool isLiteral() const { return (getSubclassData() & SCDB_IsLiteral) != 0; }
+  bool isLiteral() const { return TypeSubclassData().IsLiteral; }
 
   /// Return true if this is a type with an identity that has no body specified
   /// yet. These prints as 'opaque' in .ll files.
-  bool isOpaque() const { return (getSubclassData() & SCDB_HasBody) == 0; }
+  bool isOpaque() const { return !TypeSubclassData().HasBody; }
 
   /// isSized - Return true if this is a sized type.
   bool isSized(SmallPtrSetImpl<Type *> *Visited = nullptr) const;
 
   /// Return true if this is a named struct that has a non-empty name.
   bool hasName() const { return SymbolTableEntry != nullptr; }
 
   /// Return the name for this struct type if it has an identity.

 ElementCount Type::getVectorElementCount() const {
   return cast<VectorType>(this)->getElementCount();
 }
 
 /// Class to represent pointers.
 class PointerType : public Type {
   explicit PointerType(Type *ElType, unsigned AddrSpace);
 
+  BEGIN_TYPE_SUBCLASS_DATA(PointerType)
+    ADD_TYPE_SUBCLASS_BITFIELD(unsigned, 24, AddressSpace)
+    END_TYPE_SUBCLASS_DATA()
+
   Type *PointeeTy;
 
 public:
   PointerType(const PointerType &) = delete;
   PointerType &operator=(const PointerType &) = delete;
 
   /// This constructs a pointer to an object of the specified type in a numbered
   /// address space.
public:
 
   /// Return true if the specified type is valid as a element type.
   static bool isValidElementType(Type *ElemTy);
 
   /// Return true if we can load or store from a pointer to this type.
   static bool isLoadableOrStorableType(Type *ElemTy);
 
   /// Return the address space of the Pointer type.
-  inline unsigned getAddressSpace() const { return getSubclassData(); }
+  inline unsigned getAddressSpace() const {
+    return TypeSubclassData().AddressSpace;
+  }
 
   /// Implement support type inquiry through isa, cast, and dyn_cast.
   static bool classof(const Type *T) {
     return T->getTypeID() == PointerTyID;
   }
 };
 
 Type *Type::getExtendedType() const {

llvm/include/llvm/IR/Function.h

private:
   // Important things that make up a function!
   BasicBlockListType BasicBlocks;         ///< The basic blocks
   mutable Argument *Arguments = nullptr;  ///< The formal arguments
   size_t NumArgs;
   std::unique_ptr<ValueSymbolTable>
       SymTab;                             ///< Symbol table of args/instructions
   AttributeList AttributeSets;            ///< Parameter attributes
 
-  /*
-   * Value::SubclassData
-   *
-   * bit 0      : HasLazyArguments
-   * bit 1      : HasPrefixData
-   * bit 2      : HasPrologueData
-   * bit 3      : HasPersonalityFn
-   * bits 4-13  : CallingConvention
-   * bits 14    : HasGC
-   * bits 15 : [reserved]
-   */
-
-  /// Bits from GlobalObject::GlobalObjectSubclassData.
-  enum {
-    /// Whether this function is materializable.
-    IsMaterializableBit = 0,
-  };
+  BEGIN_VALUE_SUBCLASS_DATA(Function)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, HasLazyArguments)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, HasPrefixData)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, HasPrologueData)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, HasPersonalityFn)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, HasGC)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, IsMaterializable)
+    ADD_VALUE_SUBCLASS_BITFIELD(CallingConv::ID, 10, CallingConvention)
+    END_VALUE_SUBCLASS_DATA()
 
   friend class SymbolTableListTraits<Function>;
 
   /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
   /// built on demand, so that the list isn't allocated until the first client
   /// needs it.  The hasLazyArguments predicate returns true if the arg list
   /// hasn't been set up yet.
 public:
-  bool hasLazyArguments() const {
-    return getSubclassDataFromValue() & (1<<0);
-  }
+  bool hasLazyArguments() const { return ValueSubclassData().HasLazyArguments; }
 
 private:
   void CheckLazyArguments() const {
     if (hasLazyArguments())
       BuildLazyArguments();
   }
 
   void BuildLazyArguments() const;
public:
   /// getContext - Return a reference to the LLVMContext associated with this
   /// function.
   LLVMContext &getContext() const;
 
   /// isVarArg - Return true if this function takes a variable number of
   /// arguments.
   bool isVarArg() const { return getFunctionType()->isVarArg(); }
 
-  bool isMaterializable() const {
-    return getGlobalObjectSubClassData() & (1 << IsMaterializableBit);
-  }
-  void setIsMaterializable(bool V) {
-    unsigned Mask = 1 << IsMaterializableBit;
-    setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) |
-                                (V ? Mask : 0u));
-  }
+  bool isMaterializable() const { return ValueSubclassData().IsMaterializable; }
+  void setIsMaterializable(bool V) { ValueSubclassData().IsMaterializable = V; }
 
   /// getIntrinsicID - This method returns the ID number of the specified
   /// function, or Intrinsic::not_intrinsic if the function is not an
   /// intrinsic, or if the pointer is null.  This value is always defined to be
   /// zero to allow easy checking for whether a function is intrinsic or not.
   /// The particular intrinsic functions which correspond to this value are
   /// defined in llvm/Intrinsics.h.
   Intrinsic::ID getIntrinsicID() const LLVM_READONLY { return IntID; }
public:
   /// Note, this method does not need to be called directly, as it is called
   /// from Value::setName() whenever the name of this function changes.
   void recalculateIntrinsicID();
 
   /// getCallingConv()/setCallingConv(CC) - These method get and set the
   /// calling convention of this function.  The enum values for the known
   /// calling conventions are defined in CallingConv.h.
   CallingConv::ID getCallingConv() const {
-    return static_cast<CallingConv::ID>((getSubclassDataFromValue() >> 4) &
-                                        CallingConv::MaxID);
+    return ValueSubclassData().CallingConvention;
   }
   void setCallingConv(CallingConv::ID CC) {
-    auto ID = static_cast<unsigned>(CC);
-    assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
-    setValueSubclassData((getSubclassDataFromValue() & 0xc00f) | (ID << 4));
+    assert(!(static_cast<unsigned>(CC) & ~CallingConv::MaxID) &&
+           "Unsupported calling convention");
+    ValueSubclassData().CallingConvention = CC;
   }
 
   /// Return the attribute list for this Function.
   AttributeList getAttributes() const { return AttributeSets; }
 
   /// Set the attribute list for this Function.
   void setAttributes(AttributeList Attrs) { AttributeSets = Attrs; }
 
unsigned getFnStackAlignment() const {
     if (const auto MA =
             AttributeSets.getStackAlignment(AttributeList::FunctionIndex))
       return MA->value();
     return 0;
   }
 
   /// hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm
   ///                             to use during code generation.
-  bool hasGC() const {
-    return getSubclassDataFromValue() & (1<<14);
-  }
+  bool hasGC() const { return ValueSubclassData().HasGC; }
   const std::string &getGC() const;
   void setGC(std::string Str);
   void clearGC();
 
   /// adds the attribute to the list of attributes.
   void addAttribute(unsigned i, Attribute::AttrKind Kind);
 
   /// adds the attribute to the list of attributes.
/// @{
   }
 
 /// @}
 
   size_t arg_size() const { return NumArgs; }
   bool arg_empty() const { return arg_size() == 0; }
 
   /// Check whether this function has a personality function.
-  bool hasPersonalityFn() const {
-    return getSubclassDataFromValue() & (1<<3);
-  }
+  bool hasPersonalityFn() const { return ValueSubclassData().HasPersonalityFn; }
 
   /// Get the personality function associated with this function.
   Constant *getPersonalityFn() const;
   void setPersonalityFn(Constant *Fn);
 
   /// Check whether this function has prefix data.
-  bool hasPrefixData() const {
-    return getSubclassDataFromValue() & (1<<1);
-  }
+  bool hasPrefixData() const { return ValueSubclassData().HasPrefixData; }
 
   /// Get the prefix data associated with this function.
   Constant *getPrefixData() const;
   void setPrefixData(Constant *PrefixData);
 
   /// Check whether this function has prologue data.
-  bool hasPrologueData() const {
-    return getSubclassDataFromValue() & (1<<2);
-  }
+  bool hasPrologueData() const { return ValueSubclassData().HasPrologueData; }
 
   /// Get the prologue data associated with this function.
   Constant *getPrologueData() const;
   void setPrologueData(Constant *PrologueData);
 
   /// Print the function to an output stream with an optional
   /// AssemblyAnnotationWriter.
   void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW = nullptr,
/// @}
   /// the function.
   /// Return value: false => null pointer dereference is undefined.
   /// Return value: true =>  null pointer dereference is not undefined.
   bool nullPointerIsDefined() const;
 
 private:
   void allocHungoffUselist();
   template<int Idx> void setHungoffOperand(Constant *C);
-
-  /// Shadow Value::setValueSubclassData with a private forwarding method so
-  /// that subclasses cannot accidentally use it.
-  void setValueSubclassData(unsigned short D) {
-    Value::setValueSubclassData(D);
-  }
-  void setValueSubclassDataBit(unsigned Bit, bool On);
 };
 
 /// Check whether null pointer dereferencing is considered undefined behavior
 /// for a given function or an address space.
 /// Null pointer access in non-zero address space is not considered undefined.
 /// Return value: false => null pointer dereference is undefined.
 /// Return value: true =>  null pointer dereference is not undefined.
 bool NullPointerIsDefined(const Function *F, unsigned AS = 0);

llvm/include/llvm/IR/GlobalObject.h

enum VCallVisibility {
     VCallVisibilityTranslationUnit = 2,
   };
 
 protected:
   GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
                LinkageTypes Linkage, const Twine &Name,
                unsigned AddressSpace = 0)
       : GlobalValue(Ty, VTy, Ops, NumOps, Linkage, Name, AddressSpace),
-        ObjComdat(nullptr) {
-    setGlobalValueSubClassData(0);
-  }
+        ObjComdat(nullptr) {}
 
   Comdat *ObjComdat;
-  enum {
-    LastAlignmentBit = 4,
-    HasMetadataHashEntryBit,
-    HasSectionHashEntryBit,
 
-    GlobalObjectBits,
-  };
-  static const unsigned GlobalObjectSubClassDataBits =
-      GlobalValueSubClassDataBits - GlobalObjectBits;
-
-private:
-  static const unsigned AlignmentBits = LastAlignmentBit + 1;
-  static const unsigned AlignmentMask = (1 << AlignmentBits) - 1;
-  static const unsigned GlobalObjectMask = (1 << GlobalObjectBits) - 1;
+  BEGIN_GLOBALVALUE_SUBCLASS_DATA(GlobalObject)
+    ADD_GLOBALVALUE_SUBCLASS_BITFIELD(unsigned, 5, EncodedAlignment)
+    ADD_GLOBALVALUE_SUBCLASS_BITFIELD(bool,     1, HasMetadataHashEntry)
+    ADD_GLOBALVALUE_SUBCLASS_BITFIELD(bool,     1, HasSectionHashEntry)
+    END_GLOBALVALUE_SUBCLASS_DATA()
 
 public:
   GlobalObject(const GlobalObject &) = delete;
 
   unsigned getAlignment() const {
-    unsigned Data = getGlobalValueSubClassData();
-    unsigned AlignmentData = Data & AlignmentMask;
-    MaybeAlign Align = decodeMaybeAlign(AlignmentData);
+    MaybeAlign Align =
+        decodeMaybeAlign(GlobalValueSubclassData().EncodedAlignment);
     return Align ? Align->value() : 0;
   }
 
   /// FIXME: Remove this setter once the migration to MaybeAlign is over.
   LLVM_ATTRIBUTE_DEPRECATED(void setAlignment(unsigned Align),
                             "Please use `void setAlignment(MaybeAlign Align)`");
   void setAlignment(MaybeAlign Align);
 
-  unsigned getGlobalObjectSubClassData() const {
-    unsigned ValueData = getGlobalValueSubClassData();
-    return ValueData >> GlobalObjectBits;
-  }
-
-  void setGlobalObjectSubClassData(unsigned Val) {
-    unsigned OldData = getGlobalValueSubClassData();
-    setGlobalValueSubClassData((OldData & GlobalObjectMask) |
-                               (Val << GlobalObjectBits));
-    assert(getGlobalObjectSubClassData() == Val && "representation error");
-  }
-
   /// Check if this global has a custom object file section.
   ///
   /// This is more efficient than calling getSection() and checking for an empty
   /// string.
   bool hasSection() const {
-    return getGlobalValueSubClassData() & (1 << HasSectionHashEntryBit);
+    return GlobalValueSubclassData().HasSectionHashEntry;
   }
 
   /// Get the custom section of this global if it has one.
   ///
   /// If this global does not have a custom section, this will be empty and the
   /// default object file section (.text, .data, etc) will be used.
   StringRef getSection() const {
     return hasSection() ? getSectionImpl() : StringRef();
public:
   static bool classof(const Value *V) {
     return V->getValueID() == Value::FunctionVal ||
            V->getValueID() == Value::GlobalVariableVal;
   }
 
   void clearMetadata();
 
 private:
-  void setGlobalObjectFlag(unsigned Bit, bool Val) {
-    unsigned Mask = 1 << Bit;
-    setGlobalValueSubClassData((~Mask & getGlobalValueSubClassData()) |
-                               (Val ? Mask : 0u));
-  }
-
   bool hasMetadataHashEntry() const {
-    return getGlobalValueSubClassData() & (1 << HasMetadataHashEntryBit);
+    return GlobalValueSubclassData().HasMetadataHashEntry;
   }
   void setHasMetadataHashEntry(bool HasEntry) {
-    setGlobalObjectFlag(HasMetadataHashEntryBit, HasEntry);
+    GlobalValueSubclassData().HasMetadataHashEntry = HasEntry;
   }
 
   StringRef getSectionImpl() const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_IR_GLOBALOBJECT_H

llvm/include/llvm/IR/GlobalValue.h

 
 namespace Intrinsic {
 typedef unsigned ID;
 } // end namespace Intrinsic
 
 class GlobalValue : public Constant {
 public:
   /// An enumeration for the kinds of linkage for global values.
-  enum LinkageTypes {
+  enum LinkageTypes : unsigned {
     ExternalLinkage = 0,///< Externally visible function
     AvailableExternallyLinkage, ///< Available for inspection, not emission.
     LinkOnceAnyLinkage, ///< Keep one copy of function when linking (inline)
     LinkOnceODRLinkage, ///< Same, but only replaced by something equivalent.
     WeakAnyLinkage,     ///< Keep one copy of named function when linking (weak)
     WeakODRLinkage,     ///< Same, but only replaced by something equivalent.
     AppendingLinkage,   ///< Special purpose, only applies to global arrays
     InternalLinkage,    ///< Rename collisions when linking (static functions).
     PrivateLinkage,     ///< Like Internal, but omit from symbol table.
     ExternalWeakLinkage,///< ExternalWeak linkage description.
     CommonLinkage       ///< Tentative definitions.
   };
 
   /// An enumeration for the kinds of visibility of global values.
-  enum VisibilityTypes {
+  enum VisibilityTypes : unsigned {
     DefaultVisibility = 0,  ///< The GV is visible
     HiddenVisibility,       ///< The GV is hidden
     ProtectedVisibility     ///< The GV is protected
   };
 
   /// Storage classes of global values for PE targets.
-  enum DLLStorageClassTypes {
+  enum DLLStorageClassTypes : unsigned {
     DefaultStorageClass   = 0,
     DLLImportStorageClass = 1, ///< Function to be imported from DLL
     DLLExportStorageClass = 2  ///< Function to be accessible from DLL.
   };
 
+  enum ThreadLocalMode : unsigned {
+    NotThreadLocal = 0,
+    GeneralDynamicTLSModel,
+    LocalDynamicTLSModel,
+    InitialExecTLSModel,
+    LocalExecTLSModel
+  };
+
+  enum class UnnamedAddr : unsigned {
+    None,
+    Local,
+    Global,
+  };
+
 protected:
   GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
               LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace)
       : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
-        ValueType(Ty), Visibility(DefaultVisibility),
-        UnnamedAddrVal(unsigned(UnnamedAddr::None)),
-        DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
-        HasLLVMReservedName(false), IsDSOLocal(false), HasPartition(false),
-        IntID((Intrinsic::ID)0U), Parent(nullptr) {
+        ValueType(Ty), IntID((Intrinsic::ID)0U), Parent(nullptr) {
     setLinkage(Linkage);
     setName(Name);
   }
 
   Type *ValueType;
 
-  static const unsigned GlobalValueSubClassDataBits = 16;
+  BEGIN_PACKED_BITFIELDS(32)
+    // The linkage of this global.
+    ADD_PACKED_BITFIELD(LinkageTypes, 4, Linkage)
 
-  // All bitfields use unsigned as the underlying type so that MSVC will pack
-  // them.
-  unsigned Linkage : 4;       // The linkage of this global
-  unsigned Visibility : 2;    // The visibility style of this global
-  unsigned UnnamedAddrVal : 2; // This value's address is not significant
-  unsigned DllStorageClass : 2; // DLL storage class
-
-  unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is
-                            // the desired model?
-
-  /// True if the function's name starts with "llvm.".  This corresponds to the
-  /// value of Function::isIntrinsic(), which may be true even if
-  /// Function::intrinsicID() returns Intrinsic::not_intrinsic.
-  unsigned HasLLVMReservedName : 1;
-
-  /// If true then there is a definition within the same linkage unit and that
-  /// definition cannot be runtime preempted.
-  unsigned IsDSOLocal : 1;
-
-  /// True if this symbol has a partition name assigned (see
-  /// https://lld.llvm.org/Partitions.html).
-  unsigned HasPartition : 1;
+    // The visibility style of this global.
+    ADD_PACKED_BITFIELD(VisibilityTypes, 2, Visibility)
 
-private:
-  // Give subclasses access to what otherwise would be wasted padding.
-  // (16 + 4 + 2 + 2 + 2 + 3 + 1 + 1 + 1) == 32.
-  unsigned SubClassData : GlobalValueSubClassDataBits;
+    // This value's address is not significant.
+    ADD_PACKED_BITFIELD(UnnamedAddr, 2, UnnamedAddrVal)
+
+    // DLL storage class.
+    ADD_PACKED_BITFIELD(DLLStorageClassTypes, 2, DllStorageClass)
+
+    // Is this symbol "Thread Local", if so, what is the desired model?
+    ADD_PACKED_BITFIELD(ThreadLocalMode, 3, ThreadLocal)
+
+    // True if the function's name starts with "llvm.".  This corresponds to the
+    // value of Function::isIntrinsic(), which may be true even if
+    // Function::intrinsicID() returns Intrinsic::not_intrinsic.
+    ADD_PACKED_BITFIELD(bool, 1, HasLLVMReservedName)
 
+    // If true then there is a definition within the same linkage unit and that
+    // definition cannot be runtime preempted.
+    ADD_PACKED_BITFIELD(bool, 1, IsDSOLocal)
+
+    // True if this symbol has a partition name assigned (see
+    // https://lld.llvm.org/Partitions.html).
+    ADD_PACKED_BITFIELD(bool, 1, HasPartition)
+    END_PACKED_BITFIELDS();
+
+  DECLARE_SUBCLASS_DATA(GlobalValue)
+
+private:
   friend class Constant;
 
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
 
   /// Returns true if the definition of this global may be replaced by a
   /// differently optimized variant of the same source level function at link
   /// time.
protected:
   /// The intrinsic ID for this subclass (which must be a Function).
   ///
   /// This member is defined by this class, but not used for anything.
   /// Subclasses can use it to store their intrinsic ID, if they have one.
   ///
   /// This is stored here to save space in Function on 64-bit hosts.
   Intrinsic::ID IntID;
 
-  unsigned getGlobalValueSubClassData() const {
-    return SubClassData;
-  }
-  void setGlobalValueSubClassData(unsigned V) {
-    assert(V < (1 << GlobalValueSubClassDataBits) && "It will not fit");
-    SubClassData = V;
-  }
-
   Module *Parent;             // The containing module.
 
   // Used by SymbolTableListTraits.
   void setParent(Module *parent) {
     Parent = parent;
   }
 
   ~GlobalValue() {
     removeDeadConstantUsers();   // remove any dead constants using this.
   }
 
 public:
-  enum ThreadLocalMode {
-    NotThreadLocal = 0,
-    GeneralDynamicTLSModel,
-    LocalDynamicTLSModel,
-    InitialExecTLSModel,
-    LocalExecTLSModel
-  };
-
   GlobalValue(const GlobalValue &) = delete;
 
   unsigned getAlignment() const;
   unsigned getAddressSpace() const;
 
-  enum class UnnamedAddr {
-    None,
-    Local,
-    Global,
-  };
-
   bool hasGlobalUnnamedAddr() const {
     return getUnnamedAddr() == UnnamedAddr::Global;
   }
 
   /// Returns true if this value's address is not significant in this module.
   /// This attribute is intended to be used only by the code generator and LTO
   /// to allow the linker to decide whether the global needs to be in the symbol
   /// table. It should probably not be used in optimizations, as the value may
   /// have uses outside the module; use hasGlobalUnnamedAddr() instead.
   bool hasAtLeastLocalUnnamedAddr() const {
     return getUnnamedAddr() != UnnamedAddr::None;
   }
 
-  UnnamedAddr getUnnamedAddr() const {
-    return UnnamedAddr(UnnamedAddrVal);
-  }
-  void setUnnamedAddr(UnnamedAddr Val) { UnnamedAddrVal = unsigned(Val); }
+  UnnamedAddr getUnnamedAddr() const { return UnnamedAddrVal; }
+  void setUnnamedAddr(UnnamedAddr Val) { UnnamedAddrVal = Val; }
 
   static UnnamedAddr getMinUnnamedAddr(UnnamedAddr A, UnnamedAddr B) {
     if (A == UnnamedAddr::None || B == UnnamedAddr::None)
       return UnnamedAddr::None;
     if (A == UnnamedAddr::Local || B == UnnamedAddr::Local)
       return UnnamedAddr::Local;
     return UnnamedAddr::Global;
   }
 
   bool hasComdat() const { return getComdat() != nullptr; }
   const Comdat *getComdat() const;
   Comdat *getComdat() {
     return const_cast<Comdat *>(
                            static_cast<const GlobalValue *>(this)->getComdat());
   }
 
-  VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
+  VisibilityTypes getVisibility() const { return Visibility; }
   bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }
   bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
   bool hasProtectedVisibility() const {
     return Visibility == ProtectedVisibility;
   }
   void setVisibility(VisibilityTypes V) {
     assert((!hasLocalLinkage() || V == DefaultVisibility) &&
            "local linkage requires default visibility");
     Visibility = V;
     maybeSetDsoLocal();
   }
 
   /// If the value is "Thread Local", its value isn't shared by the threads.
   bool isThreadLocal() const { return getThreadLocalMode() != NotThreadLocal; }
   void setThreadLocal(bool Val) {
     setThreadLocalMode(Val ? GeneralDynamicTLSModel : NotThreadLocal);
   }
   void setThreadLocalMode(ThreadLocalMode Val) {
     assert(Val == NotThreadLocal || getValueID() != Value::FunctionVal);
     ThreadLocal = Val;
   }
-  ThreadLocalMode getThreadLocalMode() const {
-    return static_cast<ThreadLocalMode>(ThreadLocal);
-  }
+  ThreadLocalMode getThreadLocalMode() const { return ThreadLocal; }
 
-  DLLStorageClassTypes getDLLStorageClass() const {
-    return DLLStorageClassTypes(DllStorageClass);
-  }
+  DLLStorageClassTypes getDLLStorageClass() const { return DllStorageClass; }
   bool hasDLLImportStorageClass() const {
     return DllStorageClass == DLLImportStorageClass;
   }
   bool hasDLLExportStorageClass() const {
     return DllStorageClass == DLLExportStorageClass;
   }
   void setDLLStorageClass(DLLStorageClassTypes C) { DllStorageClass = C; }
 
public:
   }
 
   void setLinkage(LinkageTypes LT) {
     if (isLocalLinkage(LT))
       Visibility = DefaultVisibility;
     Linkage = LT;
     maybeSetDsoLocal();
   }
-  LinkageTypes getLinkage() const { return LinkageTypes(Linkage); }
+  LinkageTypes getLinkage() const { return Linkage; }
 
   bool isDiscardableIfUnused() const {
     return isDiscardableIfUnused(getLinkage());
   }
 
   bool isWeakForLinker() const { return isWeakForLinker(getLinkage()); }
 
 protected:
/// @}
   /// True if GV can be left out of the object symbol table. This is the case
   /// for linkonce_odr values whose address is not significant. While legal, it
   /// is not normally profitable to omit them from the .o symbol table. Using
   /// this analysis makes sense when the information can be passed down to the
   /// linker or we are in LTO.
   bool canBeOmittedFromSymbolTable() const;
 };
 
+#define BEGIN_GLOBALVALUE_SUBCLASS_DATA(Class)                                 \
+  BEGIN_SUBCLASS_DATA(GlobalValue, Class)
+
+#define ADD_GLOBALVALUE_SUBCLASS_BITFIELD(Type, Bits, Name)                    \
+  ADD_SUBCLASS_BITFIELD(GlobalValue, Type, Bits, Name)
+
+#define END_GLOBALVALUE_SUBCLASS_DATA()                                        \
+  END_SUBCLASS_DATA(GlobalValue)
+
 } // end namespace llvm
 
 #endif // LLVM_IR_GLOBALVALUE_H

llvm/include/llvm/IR/InstrTypes.h

 
 //===----------------------------------------------------------------------===//
 //                                UnaryOperator Class
 //===----------------------------------------------------------------------===//
 
 class UnaryOperator : public UnaryInstruction {
   void AssertOK();
 
+  BEGIN_VALUE_SUBCLASS_DATA(UnaryOperator)
+    ADD_VALUE_SUBCLASS_OPTIONALDATA()
+    END_VALUE_SUBCLASS_DATA()
+
 protected:
   UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
                 const Twine &Name, Instruction *InsertBefore);
   UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
                 const Twine &Name, BasicBlock *InsertAtEnd);
 
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;

 
 //===----------------------------------------------------------------------===//
 //                           BinaryOperator Class
 //===----------------------------------------------------------------------===//
 
 class BinaryOperator : public Instruction {
   void AssertOK();
 
+  BEGIN_VALUE_SUBCLASS_DATA(BinaryOperator)
+    ADD_VALUE_SUBCLASS_OPTIONALDATA()
+    END_VALUE_SUBCLASS_DATA()
+
 protected:
   BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
                  const Twine &Name, Instruction *InsertBefore);
   BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
                  const Twine &Name, BasicBlock *InsertAtEnd);
 
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
public:
   /// This enumeration lists the possible predicates for CmpInst subclasses.
   /// Values in the range 0-31 are reserved for FCmpInst, while values in the
   /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
   /// predicate values are not overlapping between the classes.
   ///
   /// Some passes (e.g. InstCombine) depend on the bit-wise characteristics of
   /// FCMP_* values. Changing the bit patterns requires a potential change to
   /// those passes.
-  enum Predicate {
+  enum Predicate : unsigned {
     // Opcode              U L G E    Intuitive operation
     FCMP_FALSE =  0,  ///< 0 0 0 0    Always false (always folded)
     FCMP_OEQ   =  1,  ///< 0 0 0 1    True if ordered and equal
     FCMP_OGT   =  2,  ///< 0 0 1 0    True if ordered and greater than
     FCMP_OGE   =  3,  ///< 0 0 1 1    True if ordered and greater than or equal
     FCMP_OLT   =  4,  ///< 0 1 0 0    True if ordered and less than
     FCMP_OLE   =  5,  ///< 0 1 0 1    True if ordered and less than or equal
     FCMP_ONE   =  6,  ///< 0 1 1 0    True if ordered and operands are unequal
enum Predicate : unsigned {
     ICMP_SLT   = 40,  ///< signed less than
     ICMP_SLE   = 41,  ///< signed less or equal
     FIRST_ICMP_PREDICATE = ICMP_EQ,
     LAST_ICMP_PREDICATE = ICMP_SLE,
     BAD_ICMP_PREDICATE = ICMP_SLE + 1
   };
 
 protected:
+  BEGIN_VALUE_SUBCLASS_DATA(CmpInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(Predicate, 6, Predicate)
+    END_VALUE_SUBCLASS_DATA()
+
   CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
           Value *LHS, Value *RHS, const Twine &Name = "",
           Instruction *InsertBefore = nullptr,
           Instruction *FlagsSource = nullptr);
 
   CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
           Value *LHS, Value *RHS, const Twine &Name,
           BasicBlock *InsertAtEnd);
static CmpInst *Create(OtherOps Op, Predicate predicate, Value *S1,
                          Value *S2, const Twine &Name, BasicBlock *InsertAtEnd);
 
   /// Get the opcode casted to the right type
   OtherOps getOpcode() const {
     return static_cast<OtherOps>(Instruction::getOpcode());
   }
 
   /// Return the predicate for this instruction.
-  Predicate getPredicate() const {
-    return Predicate(getSubclassDataFromInstruction());
-  }
+  Predicate getPredicate() const { return ValueSubclassData().Predicate; }
 
   /// Set the predicate for this instruction to the specified value.
-  void setPredicate(Predicate P) { setInstructionSubclassData(P); }
+  void setPredicate(Predicate P) { ValueSubclassData().Predicate = P; }
 
   static bool isFPPredicate(Predicate P) {
     return P >= FIRST_FCMP_PREDICATE && P <= LAST_FCMP_PREDICATE;
   }
 
   static bool isIntPredicate(Predicate P) {
     return P >= FIRST_ICMP_PREDICATE && P <= LAST_ICMP_PREDICATE;
   }
public:
   /// Create a result type for fcmp/icmp
   static Type* makeCmpResultType(Type* opnd_type) {
     if (VectorType* vt = dyn_cast<VectorType>(opnd_type)) {
       return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
                              vt->getElementCount());
     }
     return Type::getInt1Ty(opnd_type->getContext());
   }
-
-private:
-  // Shadow Value::setValueSubclassData with a private forwarding method so that
-  // subclasses cannot accidentally use it.
-  void setValueSubclassData(unsigned short D) {
-    Value::setValueSubclassData(D);
-  }
 };
 
 // FIXME: these are redundant if CmpInst < BinaryOperator
 template <>
 struct OperandTraits<CmpInst> : public FixedNumOperandTraits<CmpInst, 2> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CmpInst, Value)

 class CallBase : public Instruction {
 protected:
   /// The last operand is the called operand.
   static constexpr int CalledOperandOpEndIdx = -1;
 
   AttributeList Attrs; ///< parameter attributes for callable
   FunctionType *FTy;
 
+  BEGIN_VALUE_SUBCLASS_DATA(CallBase)
+    ADD_VALUE_SUBCLASS_BITFIELD(CallingConv::ID, 10, CallingConvention)
+    END_VALUE_SUBCLASS_DATA()
+
   template <class... ArgsTy>
   CallBase(AttributeList const &A, FunctionType *FT, ArgsTy &&... Args)
       : Instruction(std::forward<ArgsTy>(Args)...), Attrs(A), FTy(FT) {}
 
   using Instruction::Instruction;
 
-  bool hasDescriptor() const { return Value::HasDescriptor; }
+  bool hasDescriptor() const { return User::ValueSubclassData().HasDescriptor; }
 
   unsigned getNumSubclassExtraOperands() const {
     switch (getOpcode()) {
     case Instruction::Call:
       return 0;
     case Instruction::Invoke:
       return 2;
     case Instruction::CallBr:
assert(FTy == cast<FunctionType>(
                       cast<PointerType>(Fn->getType())->getElementType()));
     // This function doesn't mutate the return type, only the function
     // type. Seems broken, but I'm just gonna stick an assert in for now.
     assert(getType() == FTy->getReturnType());
     setCalledOperand(Fn);
   }
 
   CallingConv::ID getCallingConv() const {
-    return static_cast<CallingConv::ID>(getSubclassDataFromInstruction() >> 2);
+    return ValueSubclassData().CallingConvention;
   }
 
   void setCallingConv(CallingConv::ID CC) {
-    auto ID = static_cast<unsigned>(CC);
-    assert(!(ID & ~CallingConv::MaxID) && "Unsupported calling convention");
-    setInstructionSubclassData((getSubclassDataFromInstruction() & 3) |
-                               (ID << 2));
+    assert(!(static_cast<unsigned>(CC) & ~CallingConv::MaxID) &&
+           "Unsupported calling convention");
+    ValueSubclassData().CallingConvention = CC;
   }
 
   /// Check if this call is an inline asm statement.
   bool isInlineAsm() const { return isa<InlineAsm>(getCalledOperand()); }
 
   /// \name Attribute API
   ///
   /// These methods access and modify attributes on this call (including

llvm/include/llvm/IR/Instruction.h

template <> struct ilist_alloc_traits<Instruction> {
   static inline void deleteNode(Instruction *V);
 };
 
 class Instruction : public User,
                     public ilist_node_with_parent<Instruction, BasicBlock> {
   BasicBlock *Parent;
   DebugLoc DbgLoc;                         // 'dbg' Metadata cache.
 
-  enum {
-    /// This is a bit stored in the SubClassData field which indicates whether
-    /// this instruction has metadata attached to it or not.
-    HasMetadataBit = 1 << 15
-  };
-
 protected:
+  BEGIN_VALUE_SUBCLASS_DATA(Instruction)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, HasMetadata) // has metadata attached
+    END_VALUE_SUBCLASS_DATA()
+
   ~Instruction(); // Use deleteValue() to delete a generic Instruction.
 
 public:
   Instruction(const Instruction &) = delete;
   Instruction &operator=(const Instruction &) = delete;
 
   /// Specialize the methods defined in Value, as we know that an instruction
   /// can only be used by other instructions.
public:
   ///  3) Merging of call instructions should be extremely rare in real
   ///     applications, thus the N-way merging should be in code path.
   /// The DebugLoc attached to this instruction will be overwritten by the
   /// merged DebugLoc.
   void applyMergedLocation(const DILocation *LocA, const DILocation *LocB);
 
 private:
   /// Return true if we have an entry in the on-the-side metadata hash.
-  bool hasMetadataHashEntry() const {
-    return (getSubclassDataFromValue() & HasMetadataBit) != 0;
-  }
+  bool hasMetadataHashEntry() const { return ValueSubclassData().HasMetadata; }
 
   // These are all implemented in Metadata.cpp.
   MDNode *getMetadataImpl(unsigned KindID) const;
   MDNode *getMetadataImpl(StringRef Kind) const;
   void
   getAllMetadataImpl(SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
   void getAllMetadataOtherThanDebugLocImpl(
       SmallVectorImpl<std::pair<unsigned, MDNode *>> &) const;
public:
   ///
   Instruction *clone() const;
 
   /// Return true if the specified instruction is exactly identical to the
   /// current one. This means that all operands match and any extra information
   /// (e.g. load is volatile) agree.
   bool isIdenticalTo(const Instruction *I) const;
 
-  /// This is like isIdenticalTo, except that it ignores the
-  /// SubclassOptionalData flags, which may specify conditions under which the
-  /// instruction's result is undefined.
+  /// This is like isIdenticalTo, except that it ignores the OptionalData flags,
+  /// which may specify conditions under which the instruction's result is
+  /// undefined.
   bool isIdenticalToWhenDefined(const Instruction *I) const;
 
   /// When checking for operation equivalence (using isSameOperationAs) it is
   /// sometimes useful to ignore certain attributes.
   enum OperationEquivalenceFlags {
     /// Check for equivalence ignoring load/store alignment.
     CompareIgnoringAlignment = 1<<0,
     /// Check for equivalence treating a type and a vector of that type

 #define HANDLE_OTHER_INST(N, OPC, CLASS) OPC = N,
 #define   LAST_OTHER_INST(N)             OtherOpsEnd = N+1
 #include "llvm/IR/Instruction.def"
   };
 
 private:
   friend class SymbolTableListTraits<Instruction>;
 
-  // Shadow Value::setValueSubclassData with a private forwarding method so that
-  // subclasses cannot accidentally use it.
-  void setValueSubclassData(unsigned short D) {
-    Value::setValueSubclassData(D);
-  }
-
-  unsigned short getSubclassDataFromValue() const {
-    return Value::getSubclassDataFromValue();
-  }
-
-  void setHasMetadataHashEntry(bool V) {
-    setValueSubclassData((getSubclassDataFromValue() & ~HasMetadataBit) |
-                         (V ? HasMetadataBit : 0));
-  }
+  void setHasMetadataHashEntry(bool V) { ValueSubclassData().HasMetadata = V; }
 
   void setParent(BasicBlock *P);
 
 protected:
-  // Instruction subclasses can stick up to 15 bits of stuff into the
-  // SubclassData field of instruction with these members.
-
-  // Verify that only the low 15 bits are used.
-  void setInstructionSubclassData(unsigned short D) {
-    assert((D & HasMetadataBit) == 0 && "Out of range value put into field");
-    setValueSubclassData((getSubclassDataFromValue() & HasMetadataBit) | D);
-  }
-
-  unsigned getSubclassDataFromInstruction() const {
-    return getSubclassDataFromValue() & ~HasMetadataBit;
-  }
-
   Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
               Instruction *InsertBefore = nullptr);
   Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
               BasicBlock *InsertAtEnd);
 
 private:
   /// Create a copy of this instruction.
   Instruction *cloneImpl() const;

llvm/include/llvm/IR/Instructions.h

 //===----------------------------------------------------------------------===//
 //                                AllocaInst Class
 //===----------------------------------------------------------------------===//
 
 /// an instruction to allocate memory on the stack
 class AllocaInst : public UnaryInstruction {
   Type *AllocatedType;
 
+  BEGIN_VALUE_SUBCLASS_DATA(AllocaInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(unsigned, 5, EncodedAlignment)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool,     1, IsUsedWithInAlloca)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool,     1, IsSwiftError)
+    END_VALUE_SUBCLASS_DATA()
+
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   AllocaInst *cloneImpl() const;
 
 public:
   explicit AllocaInst(Type *Ty, unsigned AddrSpace,
public:
   Type *getAllocatedType() const { return AllocatedType; }
   /// for use only in special circumstances that need to generically
   /// transform a whole instruction (eg: IR linking and vectorization).
   void setAllocatedType(Type *Ty) { AllocatedType = Ty; }
 
   /// Return the alignment of the memory that is being allocated by the
   /// instruction.
   unsigned getAlignment() const {
-    if (const auto MA = decodeMaybeAlign(getSubclassDataFromInstruction() & 31))
+    if (const auto MA = decodeMaybeAlign(ValueSubclassData().EncodedAlignment))
       return MA->value();
     return 0;
   }
   void setAlignment(MaybeAlign Align);
 
   /// Return true if this alloca is in the entry block of the function and is a
   /// constant size. If so, the code generator will fold it into the
   /// prolog/epilog code, so it is basically free.
   bool isStaticAlloca() const;
 
   /// Return true if this alloca is used as an inalloca argument to a call. Such
   /// allocas are never considered static even if they are in the entry block.
   bool isUsedWithInAlloca() const {
-    return getSubclassDataFromInstruction() & 32;
+    return ValueSubclassData().IsUsedWithInAlloca;
   }
 
   /// Specify whether this alloca is used to represent the arguments to a call.
   void setUsedWithInAlloca(bool V) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~32) |
-                               (V ? 32 : 0));
+    ValueSubclassData().IsUsedWithInAlloca = V;
   }
 
   /// Return true if this alloca is used as a swifterror argument to a call.
-  bool isSwiftError() const {
-    return getSubclassDataFromInstruction() & 64;
-  }
+  bool isSwiftError() const { return ValueSubclassData().IsSwiftError; }
 
   /// Specify whether this alloca is used to represent a swifterror.
-  void setSwiftError(bool V) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~64) |
-                               (V ? 64 : 0));
-  }
+  void setSwiftError(bool V) { ValueSubclassData().IsSwiftError = V; }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::Alloca);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
-
-private:
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
 };
 
 //===----------------------------------------------------------------------===//
 //                                LoadInst Class
 //===----------------------------------------------------------------------===//
 
-/// An instruction for reading from memory. This uses the SubclassData field in
-/// Value to store whether or not the load is volatile.
+/// An instruction for reading from memory. This uses the ValueSubclassData to
+/// store whether or not the load is volatile.
 class LoadInst : public UnaryInstruction {
   void AssertOK();
 
+  BEGIN_VALUE_SUBCLASS_DATA(LoadInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool,           1, IsVolatile)
+    ADD_VALUE_SUBCLASS_BITFIELD(AtomicOrdering, 3, Ordering)
+    ADD_VALUE_SUBCLASS_BITFIELD(SyncScope::ID,  bit_sizeof<SyncScope::ID>(),
+                                SSID)
+    ADD_VALUE_SUBCLASS_BITFIELD(unsigned,       5, EncodedAlignment)
+    END_VALUE_SUBCLASS_DATA()
+
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   LoadInst *cloneImpl() const;
 
 public:
   LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr = "",
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, MaybeAlign Align,
       : LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
                  isVolatile, Align, Order, SSID, InsertBefore) {}
   LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, MaybeAlign Align,
            AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd)
       : LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
                  isVolatile, Align, Order, SSID, InsertAtEnd) {}
 
   /// Return true if this is a load from a volatile memory location.
-  bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
+  bool isVolatile() const { return ValueSubclassData().IsVolatile; }
 
   /// Specify whether this is a volatile load or not.
-  void setVolatile(bool V) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
-                               (V ? 1 : 0));
-  }
+  void setVolatile(bool V) { ValueSubclassData().IsVolatile = V; }
 
   /// Return the alignment of the access that is being performed.
   /// FIXME: Remove this function once transition to Align is over.
   /// Use getAlign() instead.
   unsigned getAlignment() const {
     if (const auto MA = getAlign())
       return MA->value();
     return 0;
   }
 
   /// Return the alignment of the access that is being performed.
   MaybeAlign getAlign() const {
-    return decodeMaybeAlign((getSubclassDataFromInstruction() >> 1) & 31);
+    return decodeMaybeAlign(ValueSubclassData().EncodedAlignment);
   }
 
   void setAlignment(MaybeAlign Alignment);
 
   /// Returns the ordering constraint of this load instruction.
-  AtomicOrdering getOrdering() const {
-    return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
-  }
+  AtomicOrdering getOrdering() const { return ValueSubclassData().Ordering; }
 
   /// Sets the ordering constraint of this load instruction.  May not be Release
   /// or AcquireRelease.
   void setOrdering(AtomicOrdering Ordering) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
-                               ((unsigned)Ordering << 7));
+    ValueSubclassData().Ordering = Ordering;
   }
 
   /// Returns the synchronization scope ID of this load instruction.
-  SyncScope::ID getSyncScopeID() const {
-    return SSID;
-  }
+  SyncScope::ID getSyncScopeID() const { return ValueSubclassData().SSID; }
 
   /// Sets the synchronization scope ID of this load instruction.
-  void setSyncScopeID(SyncScope::ID SSID) {
-    this->SSID = SSID;
-  }
+  void setSyncScopeID(SyncScope::ID SSID) { ValueSubclassData().SSID = SSID; }
 
   /// Sets the ordering constraint and the synchronization scope ID of this load
   /// instruction.
   void setAtomic(AtomicOrdering Ordering,
                  SyncScope::ID SSID = SyncScope::System) {
     setOrdering(Ordering);
     setSyncScopeID(SSID);
   }
public:
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Load;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
-
-private:
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
-
-  /// The synchronization scope ID of this load instruction.  Not quite enough
-  /// room in SubClassData for everything, so synchronization scope ID gets its
-  /// own field.
-  SyncScope::ID SSID;
 };
 
 //===----------------------------------------------------------------------===//
 //                                StoreInst Class
 //===----------------------------------------------------------------------===//
 
 /// An instruction for storing to memory.
 class StoreInst : public Instruction {
   void AssertOK();
 
+  BEGIN_VALUE_SUBCLASS_DATA(StoreInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool,           1, IsVolatile)
+    ADD_VALUE_SUBCLASS_BITFIELD(AtomicOrdering, 3, Ordering)
+    ADD_VALUE_SUBCLASS_BITFIELD(SyncScope::ID,  bit_sizeof<SyncScope::ID>(),
+                                SSID)
+    ADD_VALUE_SUBCLASS_BITFIELD(unsigned,       5, EncodedAlignment)
+    END_VALUE_SUBCLASS_DATA()
+
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   StoreInst *cloneImpl() const;
 
 public:
   StoreInst(Value *Val, Value *Ptr, Instruction *InsertBefore);
StoreInst(Value *Val, Value *Ptr, bool isVolatile, MaybeAlign Align,
             AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd);
 
   // allocate space for exactly two operands
   void *operator new(size_t s) {
     return User::operator new(s, 2);
   }
 
   /// Return true if this is a store to a volatile memory location.
-  bool isVolatile() const { return getSubclassDataFromInstruction() & 1; }
+  bool isVolatile() const { return ValueSubclassData().IsVolatile; }
 
   /// Specify whether this is a volatile store or not.
-  void setVolatile(bool V) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
-                               (V ? 1 : 0));
-  }
+  void setVolatile(bool V) { ValueSubclassData().IsVolatile = V; }
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Return the alignment of the access that is being performed
   /// FIXME: Remove this function once transition to Align is over.
   /// Use getAlign() instead.
   unsigned getAlignment() const {
     if (const auto MA = getAlign())
       return MA->value();
     return 0;
   }
 
   MaybeAlign getAlign() const {
-    return decodeMaybeAlign((getSubclassDataFromInstruction() >> 1) & 31);
+    return decodeMaybeAlign(ValueSubclassData().EncodedAlignment);
   }
 
   void setAlignment(MaybeAlign Alignment);
 
   /// Returns the ordering constraint of this store instruction.
-  AtomicOrdering getOrdering() const {
-    return AtomicOrdering((getSubclassDataFromInstruction() >> 7) & 7);
-  }
+  AtomicOrdering getOrdering() const { return ValueSubclassData().Ordering; }
 
   /// Sets the ordering constraint of this store instruction.  May not be
   /// Acquire or AcquireRelease.
   void setOrdering(AtomicOrdering Ordering) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 7)) |
-                               ((unsigned)Ordering << 7));
+    ValueSubclassData().Ordering = Ordering;
   }
 
   /// Returns the synchronization scope ID of this store instruction.
-  SyncScope::ID getSyncScopeID() const {
-    return SSID;
-  }
+  SyncScope::ID getSyncScopeID() const { return ValueSubclassData().SSID; }
 
   /// Sets the synchronization scope ID of this store instruction.
-  void setSyncScopeID(SyncScope::ID SSID) {
-    this->SSID = SSID;
-  }
+  void setSyncScopeID(SyncScope::ID SSID) { ValueSubclassData().SSID = SSID; }
 
   /// Sets the ordering constraint and the synchronization scope ID of this
   /// store instruction.
   void setAtomic(AtomicOrdering Ordering,
                  SyncScope::ID SSID = SyncScope::System) {
     setOrdering(Ordering);
     setSyncScopeID(SSID);
   }
public:
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Store;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
-
-private:
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
-
-  /// The synchronization scope ID of this store instruction.  Not quite enough
-  /// room in SubClassData for everything, so synchronization scope ID gets its
-  /// own field.
-  SyncScope::ID SSID;
 };
 
 template <>
 struct OperandTraits<StoreInst> : public FixedNumOperandTraits<StoreInst, 2> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(StoreInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                                FenceInst Class
 //===----------------------------------------------------------------------===//
 
 /// An instruction for ordering other memory operations.
 class FenceInst : public Instruction {
+  BEGIN_VALUE_SUBCLASS_DATA(FenceInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(AtomicOrdering, 3, Ordering)
+    ADD_VALUE_SUBCLASS_BITFIELD(SyncScope::ID,  bit_sizeof<SyncScope::ID>(),
+                                SSID)
+    END_VALUE_SUBCLASS_DATA()
+
   void Init(AtomicOrdering Ordering, SyncScope::ID SSID);
 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   FenceInst *cloneImpl() const;
 
 public:
   // Ordering may only be Acquire, Release, AcquireRelease, or
   // SequentiallyConsistent.
   FenceInst(LLVMContext &C, AtomicOrdering Ordering,
             SyncScope::ID SSID = SyncScope::System,
             Instruction *InsertBefore = nullptr);
   FenceInst(LLVMContext &C, AtomicOrdering Ordering, SyncScope::ID SSID,
             BasicBlock *InsertAtEnd);
 
   // allocate space for exactly zero operands
   void *operator new(size_t s) {
     return User::operator new(s, 0);
   }
 
   /// Returns the ordering constraint of this fence instruction.
-  AtomicOrdering getOrdering() const {
-    return AtomicOrdering(getSubclassDataFromInstruction() >> 1);
-  }
+  AtomicOrdering getOrdering() const { return ValueSubclassData().Ordering; }
 
   /// Sets the ordering constraint of this fence instruction.  May only be
   /// Acquire, Release, AcquireRelease, or SequentiallyConsistent.
   void setOrdering(AtomicOrdering Ordering) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & 1) |
-                               ((unsigned)Ordering << 1));
+    ValueSubclassData().Ordering = Ordering;
   }
 
   /// Returns the synchronization scope ID of this fence instruction.
-  SyncScope::ID getSyncScopeID() const {
-    return SSID;
-  }
+  SyncScope::ID getSyncScopeID() const { return ValueSubclassData().SSID; }
 
   /// Sets the synchronization scope ID of this fence instruction.
-  void setSyncScopeID(SyncScope::ID SSID) {
-    this->SSID = SSID;
-  }
+  void setSyncScopeID(SyncScope::ID SSID) { ValueSubclassData().SSID = SSID; }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Fence;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
-
-private:
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
-
-  /// The synchronization scope ID of this fence instruction.  Not quite enough
-  /// room in SubClassData for everything, so synchronization scope ID gets its
-  /// own field.
-  SyncScope::ID SSID;
 };
 
 //===----------------------------------------------------------------------===//
 //                                AtomicCmpXchgInst Class
 //===----------------------------------------------------------------------===//
 
 /// An instruction that atomically checks whether a
 /// specified value is in a memory location, and, if it is, stores a new value
 /// there. The value returned by this instruction is a pair containing the
 /// original value as first element, and an i1 indicating success (true) or
 /// failure (false) as second element.
 ///
 class AtomicCmpXchgInst : public Instruction {
+  BEGIN_VALUE_SUBCLASS_DATA(AtomicCmpXchgInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool,           1, IsVolatile)
+    ADD_VALUE_SUBCLASS_BITFIELD(AtomicOrdering, 3, SuccessOrdering)
+    ADD_VALUE_SUBCLASS_BITFIELD(AtomicOrdering, 3, FailureOrdering)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool,           1, IsWeak)
+    ADD_VALUE_SUBCLASS_BITFIELD(SyncScope::ID,  bit_sizeof<SyncScope::ID>(),
+                                SSID)
+    END_VALUE_SUBCLASS_DATA()
+
   void Init(Value *Ptr, Value *Cmp, Value *NewVal,
             AtomicOrdering SuccessOrdering, AtomicOrdering FailureOrdering,
             SyncScope::ID SSID);
 
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
public:
   // allocate space for exactly three operands
   void *operator new(size_t s) {
     return User::operator new(s, 3);
   }
 
   /// Return true if this is a cmpxchg from a volatile memory
   /// location.
   ///
-  bool isVolatile() const {
-    return getSubclassDataFromInstruction() & 1;
-  }
+  bool isVolatile() const { return ValueSubclassData().IsVolatile; }
 
   /// Specify whether this is a volatile cmpxchg.
-  ///
-  void setVolatile(bool V) {
-     setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
-                                (unsigned)V);
-  }
+  void setVolatile(bool V) { ValueSubclassData().IsVolatile = V; }
 
   /// Return true if this cmpxchg may spuriously fail.
-  bool isWeak() const {
-    return getSubclassDataFromInstruction() & 0x100;
-  }
+  bool isWeak() const { return ValueSubclassData().IsWeak; }
 
-  void setWeak(bool IsWeak) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~0x100) |
-                               (IsWeak << 8));
-  }
+  void setWeak(bool IsWeak) { ValueSubclassData().IsWeak = IsWeak; }
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Returns the success ordering constraint of this cmpxchg instruction.
   AtomicOrdering getSuccessOrdering() const {
-    return AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
+    return ValueSubclassData().SuccessOrdering;
   }
 
   /// Sets the success ordering constraint of this cmpxchg instruction.
   void setSuccessOrdering(AtomicOrdering Ordering) {
     assert(Ordering != AtomicOrdering::NotAtomic &&
            "CmpXchg instructions can only be atomic.");
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~0x1c) |
-                               ((unsigned)Ordering << 2));
+    ValueSubclassData().SuccessOrdering = Ordering;
   }
 
   /// Returns the failure ordering constraint of this cmpxchg instruction.
   AtomicOrdering getFailureOrdering() const {
-    return AtomicOrdering((getSubclassDataFromInstruction() >> 5) & 7);
+    return ValueSubclassData().FailureOrdering;
   }
 
   /// Sets the failure ordering constraint of this cmpxchg instruction.
   void setFailureOrdering(AtomicOrdering Ordering) {
     assert(Ordering != AtomicOrdering::NotAtomic &&
            "CmpXchg instructions can only be atomic.");
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~0xe0) |
-                               ((unsigned)Ordering << 5));
+    ValueSubclassData().FailureOrdering = Ordering;
   }
 
   /// Returns the synchronization scope ID of this cmpxchg instruction.
-  SyncScope::ID getSyncScopeID() const {
-    return SSID;
-  }
+  SyncScope::ID getSyncScopeID() const { return ValueSubclassData().SSID; }
 
   /// Sets the synchronization scope ID of this cmpxchg instruction.
-  void setSyncScopeID(SyncScope::ID SSID) {
-    this->SSID = SSID;
-  }
+  void setSyncScopeID(SyncScope::ID SSID) { ValueSubclassData().SSID = SSID; }
 
   Value *getPointerOperand() { return getOperand(0); }
   const Value *getPointerOperand() const { return getOperand(0); }
   static unsigned getPointerOperandIndex() { return 0U; }
 
   Value *getCompareOperand() { return getOperand(1); }
   const Value *getCompareOperand() const { return getOperand(1); }
 
public:
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::AtomicCmpXchg;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
-
-private:
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
-
-  /// The synchronization scope ID of this cmpxchg instruction.  Not quite
-  /// enough room in SubClassData for everything, so synchronization scope ID
-  /// gets its own field.
-  SyncScope::ID SSID;
 };
 
 template <>
 struct OperandTraits<AtomicCmpXchgInst> :
     public FixedNumOperandTraits<AtomicCmpXchgInst, 3> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicCmpXchgInst, Value)
protected:
 
   AtomicRMWInst *cloneImpl() const;
 
 public:
   /// This enumeration lists the possible modifications atomicrmw can make.  In
   /// the descriptions, 'p' is the pointer to the instruction's memory location,
   /// 'old' is the initial value of *p, and 'v' is the other value passed to the
   /// instruction.  These instructions always return 'old'.
-  enum BinOp {
+  enum BinOp : unsigned {
     /// *p = v
     Xchg,
     /// *p = old + v
     Add,
     /// *p = old - v
     Sub,
     /// *p = old & v
     And,
enum BinOp : unsigned {
     /// *p = old - v
     FSub,
 
     FIRST_BINOP = Xchg,
     LAST_BINOP = FSub,
     BAD_BINOP
   };
 
+private:
+  BEGIN_VALUE_SUBCLASS_DATA(AtomicRMWInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool,           1, IsVolatile)
+    ADD_VALUE_SUBCLASS_BITFIELD(AtomicOrdering, 3, Ordering)
+    ADD_VALUE_SUBCLASS_BITFIELD(SyncScope::ID,  bit_sizeof<SyncScope::ID>(),
+                                SSID)
+    ADD_VALUE_SUBCLASS_BITFIELD(BinOp,          3, Operation)
+    END_VALUE_SUBCLASS_DATA()
+
+public:
   AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
                 AtomicOrdering Ordering, SyncScope::ID SSID,
                 Instruction *InsertBefore = nullptr);
   AtomicRMWInst(BinOp Operation, Value *Ptr, Value *Val,
                 AtomicOrdering Ordering, SyncScope::ID SSID,
                 BasicBlock *InsertAtEnd);
 
   // allocate space for exactly two operands
   void *operator new(size_t s) {
     return User::operator new(s, 2);
   }
 
-  BinOp getOperation() const {
-    return static_cast<BinOp>(getSubclassDataFromInstruction() >> 5);
-  }
+  BinOp getOperation() const { return ValueSubclassData().Operation; }
 
   static StringRef getOperationName(BinOp Op);
 
   static bool isFPOperation(BinOp Op) {
     switch (Op) {
     case AtomicRMWInst::FAdd:
     case AtomicRMWInst::FSub:
       return true;
     default:
       return false;
     }
   }
 
   void setOperation(BinOp Operation) {
-    unsigned short SubclassData = getSubclassDataFromInstruction();
-    setInstructionSubclassData((SubclassData & 31) |
-                               (Operation << 5));
+    ValueSubclassData().Operation = Operation;
   }
 
   /// Return true if this is a RMW on a volatile memory location.
-  ///
-  bool isVolatile() const {
-    return getSubclassDataFromInstruction() & 1;
-  }
+  bool isVolatile() const { return ValueSubclassData().IsVolatile; }
 
   /// Specify whether this is a volatile RMW or not.
-  ///
-  void setVolatile(bool V) {
-     setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
-                                (unsigned)V);
-  }
+  void setVolatile(bool V) { ValueSubclassData().IsVolatile = V; }
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Returns the ordering constraint of this rmw instruction.
-  AtomicOrdering getOrdering() const {
-    return AtomicOrdering((getSubclassDataFromInstruction() >> 2) & 7);
-  }
+  AtomicOrdering getOrdering() const { return ValueSubclassData().Ordering; }
 
   /// Sets the ordering constraint of this rmw instruction.
   void setOrdering(AtomicOrdering Ordering) {
     assert(Ordering != AtomicOrdering::NotAtomic &&
            "atomicrmw instructions can only be atomic.");
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~(7 << 2)) |
-                               ((unsigned)Ordering << 2));
+    ValueSubclassData().Ordering = Ordering;
   }
 
   /// Returns the synchronization scope ID of this rmw instruction.
-  SyncScope::ID getSyncScopeID() const {
-    return SSID;
-  }
+  SyncScope::ID getSyncScopeID() const { return ValueSubclassData().SSID; }
 
   /// Sets the synchronization scope ID of this rmw instruction.
-  void setSyncScopeID(SyncScope::ID SSID) {
-    this->SSID = SSID;
-  }
+  void setSyncScopeID(SyncScope::ID SSID) { ValueSubclassData().SSID = SSID; }
 
   Value *getPointerOperand() { return getOperand(0); }
   const Value *getPointerOperand() const { return getOperand(0); }
   static unsigned getPointerOperandIndex() { return 0U; }
 
   Value *getValOperand() { return getOperand(1); }
   const Value *getValOperand() const { return getOperand(1); }
 
public:
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
 private:
   void Init(BinOp Operation, Value *Ptr, Value *Val,
             AtomicOrdering Ordering, SyncScope::ID SSID);
-
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
-
-  /// The synchronization scope ID of this rmw instruction.  Not quite enough
-  /// room in SubClassData for everything, so synchronization scope ID gets its
-  /// own field.
-  SyncScope::ID SSID;
 };
 
 template <>
 struct OperandTraits<AtomicRMWInst>
     : public FixedNumOperandTraits<AtomicRMWInst,2> {
 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(AtomicRMWInst, Value)

 
 /// an instruction for type-safe pointer arithmetic to
 /// access elements of arrays and structs
 ///
 class GetElementPtrInst : public Instruction {
   Type *SourceElementType;
   Type *ResultElementType;
 
+  BEGIN_VALUE_SUBCLASS_DATA(GetElementPtrInst)
+    ADD_VALUE_SUBCLASS_OPTIONALDATA()
+    END_VALUE_SUBCLASS_DATA()
+
   GetElementPtrInst(const GetElementPtrInst &GEPI);
 
   /// Constructors - Create a getelementptr instruction with a base pointer an
   /// list of indices. The first ctor can optionally insert before an existing
   /// instruction, the second appends the new instruction to the specified
   /// BasicBlock.
   inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
                            ArrayRef<Value *> IdxList, unsigned Values,
void AssertOK() {
     assert(isFPPredicate() && "Invalid FCmp predicate value");
     assert(getOperand(0)->getType() == getOperand(1)->getType() &&
            "Both operands to FCmp instruction are not of the same type!");
     // Check that the operands are the right type
     assert(getOperand(0)->getType()->isFPOrFPVectorTy() &&
            "Invalid operand types for FCmp instruction");
   }
 
+  BEGIN_VALUE_SUBCLASS_DATA(FCmpInst)
+    ADD_VALUE_SUBCLASS_OPTIONALDATA()
+    END_VALUE_SUBCLASS_DATA()
+
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   /// Clone an identical FCmpInst
   FCmpInst *cloneImpl() const;
 
 public:
public:
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };
 
 //===----------------------------------------------------------------------===//
 /// This class represents a function call, abstracting a target
-/// machine's calling convention.  This class uses low bit of the SubClassData
-/// field to indicate whether or not this is a tail call.  The rest of the bits
-/// hold the calling convention of the call.
+/// machine's calling convention.  This class uses 2 bits of the
+/// ValueSubClassData to indicate whether or not this is a tail call.  The rest
+/// of the bits hold the calling convention of the call.
 ///
 class CallInst : public CallBase {
   CallInst(const CallInst &CI);
 
   /// Construct a CallInst given a range of arguments.
   /// Construct a CallInst from a range of arguments
   inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                   ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
public:
   static Instruction *CreateFree(Value *Source,
                                  ArrayRef<OperandBundleDef> Bundles,
                                  Instruction *InsertBefore);
   static Instruction *CreateFree(Value *Source,
                                  ArrayRef<OperandBundleDef> Bundles,
                                  BasicBlock *InsertAtEnd);
 
   // Note that 'musttail' implies 'tail'.
-  enum TailCallKind {
+  enum TailCallKind : unsigned {
     TCK_None = 0,
     TCK_Tail = 1,
     TCK_MustTail = 2,
     TCK_NoTail = 3
   };
+
+private:
+  BEGIN_VALUE_SUBCLASS_DATA(CallInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(TailCallKind, 2, TailCallKind)
+    ADD_VALUE_SUBCLASS_OPTIONALDATA()
+    END_VALUE_SUBCLASS_DATA()
+
+public:
   TailCallKind getTailCallKind() const {
-    return TailCallKind(getSubclassDataFromInstruction() & 3);
+    return ValueSubclassData().TailCallKind;
   }
 
   bool isTailCall() const {
-    unsigned Kind = getSubclassDataFromInstruction() & 3;
+    TailCallKind Kind = ValueSubclassData().TailCallKind;
     return Kind == TCK_Tail || Kind == TCK_MustTail;
   }
 
   bool isMustTailCall() const {
-    return (getSubclassDataFromInstruction() & 3) == TCK_MustTail;
+    return ValueSubclassData().TailCallKind == TCK_MustTail;
   }
 
   bool isNoTailCall() const {
-    return (getSubclassDataFromInstruction() & 3) == TCK_NoTail;
+    return ValueSubclassData().TailCallKind == TCK_NoTail;
   }
 
   void setTailCall(bool isTC = true) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~3) |
-                               unsigned(isTC ? TCK_Tail : TCK_None));
+    ValueSubclassData().TailCallKind = isTC ? TCK_Tail : TCK_None;
   }
 
   void setTailCallKind(TailCallKind TCK) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~3) |
-                               unsigned(TCK));
+    ValueSubclassData().TailCallKind = TCK;
   }
 
   /// Return true if the call can return twice
   bool canReturnTwice() const { return hasFnAttr(Attribute::ReturnsTwice); }
   void setCanReturnTwice() {
     addAttribute(AttributeList::FunctionIndex, Attribute::ReturnsTwice);
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Call;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 
   /// Updates profile metadata by scaling it by \p S / \p T.
   void updateProfWeight(uint64_t S, uint64_t T);
-
-private:
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
 };
 
 CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
                    ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr,
                    BasicBlock *InsertAtEnd)
     : CallBase(Ty->getReturnType(), Instruction::Call,
                OperandTraits<CallBase>::op_end(this) -
                    (Args.size() + CountBundleInputs(Bundles) + 1),

 
 //===----------------------------------------------------------------------===//
 //                               SelectInst Class
 //===----------------------------------------------------------------------===//
 
 /// This class represents the LLVM 'select' instruction.
 ///
 class SelectInst : public Instruction {
+  BEGIN_VALUE_SUBCLASS_DATA(SelectInst)
+    ADD_VALUE_SUBCLASS_OPTIONALDATA()
+    END_VALUE_SUBCLASS_DATA()
+
   SelectInst(Value *C, Value *S1, Value *S2, const Twine &NameStr,
              Instruction *InsertBefore)
     : Instruction(S1->getType(), Instruction::Select,
                   &Op<0>(), 3, InsertBefore) {
     init(C, S1, S2);
     setName(NameStr);
   }
 

 // node, that can not exist in nature, but can be synthesized in a computer
 // scientist's overactive imagination.
 //
 class PHINode : public Instruction {
   /// The number of operands actually allocated.  NumOperands is
   /// the number actually in use.
   unsigned ReservedSpace;
 
+  BEGIN_VALUE_SUBCLASS_DATA(PHINode)
+    ADD_VALUE_SUBCLASS_OPTIONALDATA()
+    END_VALUE_SUBCLASS_DATA()
+
   PHINode(const PHINode &PN);
 
   explicit PHINode(Type *Ty, unsigned NumReservedValues,
                    const Twine &NameStr = "",
                    Instruction *InsertBefore = nullptr)
     : Instruction(Ty, Instruction::PHI, nullptr, 0, InsertBefore),
       ReservedSpace(NumReservedValues) {
     setName(NameStr);

 //                           LandingPadInst Class
 //===----------------------------------------------------------------------===//
 
 //===---------------------------------------------------------------------------
 /// The landingpad instruction holds all of the information
 /// necessary to generate correct exception handling. The landingpad instruction
 /// cannot be moved from the top of a landing pad block, which itself is
 /// accessible only from the 'unwind' edge of an invoke. This uses the
-/// SubclassData field in Value to store whether or not the landingpad is a
-/// cleanup.
+/// ValueSubclassData to store whether or not the landingpad is a cleanup.
 ///
 class LandingPadInst : public Instruction {
   /// The number of operands actually allocated.  NumOperands is
   /// the number actually in use.
   unsigned ReservedSpace;
 
+  BEGIN_VALUE_SUBCLASS_DATA(LandingPadInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, IsCleanup)
+    END_VALUE_SUBCLASS_DATA()
+
   LandingPadInst(const LandingPadInst &LP);
 
 public:
   enum ClauseType { Catch, Filter };
 
 private:
   explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
                           const Twine &NameStr, Instruction *InsertBefore);
static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
                                 const Twine &NameStr, BasicBlock *InsertAtEnd);
 
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Return 'true' if this landingpad instruction is a
   /// cleanup. I.e., it should be run when unwinding even if its landing pad
   /// doesn't catch the exception.
-  bool isCleanup() const { return getSubclassDataFromInstruction() & 1; }
+  bool isCleanup() const { return ValueSubclassData().IsCleanup; }
 
   /// Indicate that this landingpad instruction is a cleanup.
-  void setCleanup(bool V) {
-    setInstructionSubclassData((getSubclassDataFromInstruction() & ~1) |
-                               (V ? 1 : 0));
-  }
+  void setCleanup(bool V) { ValueSubclassData().IsCleanup = V; }
 
   /// Add a catch or filter clause to the landing pad.
   void addClause(Constant *ClauseVal);
 
   /// Get the value of the clause at index Idx. Use isCatch/isFilter to
   /// determine what type of clause this is.
   Constant *getClause(unsigned Idx) const {
     return cast<Constant>(getOperandList()[Idx]);

 };
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(IndirectBrInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                               InvokeInst Class
 //===----------------------------------------------------------------------===//
 
-/// Invoke instruction.  The SubclassData field is used to hold the
+/// Invoke instruction.  The ValueSubclassData is used to hold the
 /// calling convention of the call.
 ///
 class InvokeInst : public CallBase {
   /// The number of operands for this call beyond the called function,
   /// arguments, and operand bundles.
   static constexpr int NumExtraOperands = 2;
 
   /// The index from the end of the operand array to the normal destination.
public:
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::Invoke);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
-
-private:
-
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
 };
 
 InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
                        BasicBlock *IfException, ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                        const Twine &NameStr, Instruction *InsertBefore)
     : CallBase(Ty->getReturnType(), Instruction::Invoke,
                OperandTraits<CallBase>::op_end(this) - NumOperands, NumOperands,
InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
   init(Ty, Func, IfNormal, IfException, Args, Bundles, NameStr);
 }
 
 //===----------------------------------------------------------------------===//
 //                              CallBrInst Class
 //===----------------------------------------------------------------------===//
 
 /// CallBr instruction, tracking function calls that may not return control but
-/// instead transfer it to a third location. The SubclassData field is used to
+/// instead transfer it to a third location. The ValueSubclassData is used to
 /// hold the calling convention of the call.
 ///
 class CallBrInst : public CallBase {
 
   unsigned NumIndirectDests;
 
   CallBrInst(const CallBrInst &BI);
 
public:
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return (I->getOpcode() == Instruction::CallBr);
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
-
-private:
-
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
 };
 
 CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
                        ArrayRef<BasicBlock *> IndirectDests,
                        ArrayRef<Value *> Args,
                        ArrayRef<OperandBundleDef> Bundles, int NumOperands,
                        const Twine &NameStr, Instruction *InsertBefore)
     : CallBase(Ty->getReturnType(), Instruction::CallBr,

 //===----------------------------------------------------------------------===//
 //                         CatchSwitchInst Class
 //===----------------------------------------------------------------------===//
 class CatchSwitchInst : public Instruction {
   /// The number of operands actually allocated.  NumOperands is
   /// the number actually in use.
   unsigned ReservedSpace;
 
+  BEGIN_VALUE_SUBCLASS_DATA(CatchSwitchInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, HasUnwindDest)
+    END_VALUE_SUBCLASS_DATA()
+
   // Operand[0] = Outer scope
   // Operand[1] = Unwind block destination
   // Operand[n] = BasicBlock to go to on match
   CatchSwitchInst(const CatchSwitchInst &CSI);
 
   /// Create a new switch instruction, specifying a
   /// default destination.  The number of additional handlers can be specified
   /// here to make memory allocation more efficient.
public:
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   // Accessor Methods for CatchSwitch stmt
   Value *getParentPad() const { return getOperand(0); }
   void setParentPad(Value *ParentPad) { setOperand(0, ParentPad); }
 
   // Accessor Methods for CatchSwitch stmt
-  bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
+  bool hasUnwindDest() const { return ValueSubclassData().HasUnwindDest; }
   bool unwindsToCaller() const { return !hasUnwindDest(); }
   BasicBlock *getUnwindDest() const {
     if (hasUnwindDest())
       return cast<BasicBlock>(getOperand(1));
     return nullptr;
   }
   void setUnwindDest(BasicBlock *UnwindDest) {
     assert(UnwindDest);

 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CatchReturnInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                               CleanupReturnInst Class
 //===----------------------------------------------------------------------===//
 
 class CleanupReturnInst : public Instruction {
-private:
+  BEGIN_VALUE_SUBCLASS_DATA(CleanupReturnInst)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, HasUnwindDest)
+    END_VALUE_SUBCLASS_DATA()
+
   CleanupReturnInst(const CleanupReturnInst &RI);
   CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
                     Instruction *InsertBefore = nullptr);
   CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB, unsigned Values,
                     BasicBlock *InsertAtEnd);
 
   void init(Value *CleanupPad, BasicBlock *UnwindBB);
 
if (UnwindBB)
       ++Values;
     return new (Values)
         CleanupReturnInst(CleanupPad, UnwindBB, Values, InsertAtEnd);
   }
 
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
-  bool hasUnwindDest() const { return getSubclassDataFromInstruction() & 1; }
+  bool hasUnwindDest() const { return ValueSubclassData().HasUnwindDest; }
   bool unwindsToCaller() const { return !hasUnwindDest(); }
 
   /// Convenience accessor.
   CleanupPadInst *getCleanupPad() const {
     return cast<CleanupPadInst>(Op<0>());
   }
   void setCleanupPad(CleanupPadInst *CleanupPad) {
     assert(CleanupPad);
BasicBlock *getSuccessor(unsigned Idx) const {
     assert(Idx == 0);
     return getUnwindDest();
   }
 
   void setSuccessor(unsigned Idx, BasicBlock *B) {
     assert(Idx == 0);
     setUnwindDest(B);
   }
-
-  // Shadow Instruction::setInstructionSubclassData with a private forwarding
-  // method so that subclasses cannot accidentally use it.
-  void setInstructionSubclassData(unsigned short D) {
-    Instruction::setInstructionSubclassData(D);
-  }
 };
 
 template <>
 struct OperandTraits<CleanupReturnInst>
     : public VariadicOperandTraits<CleanupReturnInst, /*MINARITY=*/1> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(CleanupReturnInst, Value)
 

llvm/include/llvm/IR/Operator.h

 #include "llvm/Support/Casting.h"
 #include <cstddef>
 
 namespace llvm {
 
 /// This is a utility class that provides an abstraction for the common
 /// functionality between Instructions and ConstantExprs.
 class Operator : public User {
+protected:
+  BEGIN_VALUE_SUBCLASS_DATA(Operator)
+    ADD_VALUE_SUBCLASS_BITFIELD(unsigned, 1, Skip0)
+    ADD_VALUE_SUBCLASS_BITFIELD(unsigned,
+                                SubclassOptionalDataMinBitOffset -
+                                    (bit_offsetof<decltype(Skip0)>() + 1),
+                                Skip1)
+    END_VALUE_SUBCLASS_DATA()
+
 public:
   // The Operator class is intended to be used as a utility, and is never itself
   // instantiated.
   Operator() = delete;
   ~Operator() = delete;
 
   void *operator new(size_t s) = delete;
 
static bool classof(const Value *V) {
     return isa<Instruction>(V) || isa<ConstantExpr>(V);
   }
 };
 
 /// Utility class for integer operators which may exhibit overflow - Add, Sub,
 /// Mul, and Shl. It does not include SDiv, despite that operator having the
 /// potential for overflow.
 class OverflowingBinaryOperator : public Operator {
+  BEGIN_VALUE_SUBCLASS_DATA(OverflowingBinaryOperator)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, HasNoUnsignedWrap)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, HasNoSignedWrap)
+    END_VALUE_SUBCLASS_DATA()
+
 public:
   enum {
     NoUnsignedWrap = (1 << 0),
     NoSignedWrap   = (1 << 1)
   };
 
 private:
   friend class Instruction;
   friend class ConstantExpr;
 
   void setHasNoUnsignedWrap(bool B) {
-    SubclassOptionalData =
-      (SubclassOptionalData & ~NoUnsignedWrap) | (B * NoUnsignedWrap);
-  }
-  void setHasNoSignedWrap(bool B) {
-    SubclassOptionalData =
-      (SubclassOptionalData & ~NoSignedWrap) | (B * NoSignedWrap);
+    ValueSubclassData().HasNoUnsignedWrap = B;
   }
+  void setHasNoSignedWrap(bool B) { ValueSubclassData().HasNoSignedWrap = B; }
 
 public:
   /// Test whether this operation is known to never
   /// undergo unsigned overflow, aka the nuw property.
   bool hasNoUnsignedWrap() const {
-    return SubclassOptionalData & NoUnsignedWrap;
+    return ValueSubclassData().HasNoUnsignedWrap;
   }
 
   /// Test whether this operation is known to never
   /// undergo signed overflow, aka the nsw property.
-  bool hasNoSignedWrap() const {
-    return (SubclassOptionalData & NoSignedWrap) != 0;
-  }
+  bool hasNoSignedWrap() const { return ValueSubclassData().HasNoSignedWrap; }
 
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Add ||
            I->getOpcode() == Instruction::Sub ||
            I->getOpcode() == Instruction::Mul ||
            I->getOpcode() == Instruction::Shl;
   }
   static bool classof(const ConstantExpr *CE) {
     return CE->getOpcode() == Instruction::Add ||
            CE->getOpcode() == Instruction::Sub ||
            CE->getOpcode() == Instruction::Mul ||
            CE->getOpcode() == Instruction::Shl;
   }
   static bool classof(const Value *V) {
     return (isa<Instruction>(V) && classof(cast<Instruction>(V))) ||
            (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)));
   }
 };
 
 /// A udiv or sdiv instruction, which can be marked as "exact",
 /// indicating that no bits are destroyed.
 class PossiblyExactOperator : public Operator {
+  BEGIN_VALUE_SUBCLASS_DATA(PossiblyExactOperator)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool, 1, IsExact)
+    END_VALUE_SUBCLASS_DATA()
+
 public:
   enum {
     IsExact = (1 << 0)
   };
 
 private:
   friend class Instruction;
   friend class ConstantExpr;
 
-  void setIsExact(bool B) {
-    SubclassOptionalData = (SubclassOptionalData & ~IsExact) | (B * IsExact);
-  }
+  void setIsExact(bool B) { ValueSubclassData().IsExact = B; }
 
 public:
   /// Test whether this division is known to be exact, with zero remainder.
-  bool isExact() const {
-    return SubclassOptionalData & IsExact;
-  }
+  bool isExact() const { return ValueSubclassData().IsExact; }
 
   static bool isPossiblyExactOpcode(unsigned OpC) {
     return OpC == Instruction::SDiv ||
            OpC == Instruction::UDiv ||
            OpC == Instruction::AShr ||
            OpC == Instruction::LShr;
   }
 
FastMathFlags(unsigned F) {
     // If all 7 bits are set, turn this into -1. If the number of bits grows,
     // this must be updated. This is intended to provide some forward binary
     // compatibility insurance for the meaning of 'fast' in case bits are added.
     if (F == 0x7F) Flags = ~0U;
     else Flags = F;
   }
 
 public:
-  // This is how the bits are used in Value::SubclassOptionalData so they
-  // should fit there too.
-  // WARNING: We're out of space. SubclassOptionalData only has 7 bits. New
+  // This is how the bits are used in Instruction::OptionalData and
+  // ConstantExpr::OptionalData so they should fit there too.
+  // WARNING: We're out of space. OptionalData only has 7 bits. New
   // functionality will require a change in how this information is stored.
   enum {
     AllowReassoc    = (1 << 0),
     NoNaNs          = (1 << 1),
     NoInfs          = (1 << 2),
     NoSignedZeros   = (1 << 3),
     AllowReciprocal = (1 << 4),
     AllowContract   = (1 << 5),
public:
   void setApproxFunc(bool B = true) {
     Flags = (Flags & ~ApproxFunc) | B * ApproxFunc;
   }
   void setFast(bool B = true) { B ? set() : clear(); }
 
   void operator&=(const FastMathFlags &OtherFlags) {
     Flags &= OtherFlags.Flags;
   }
+
+  bool operator==(const FastMathFlags &OtherFlags) const {
+    return Flags == OtherFlags.Flags;
+  }
+
+  bool operator!=(const FastMathFlags &OtherFlags) const {
+    return Flags != OtherFlags.Flags;
+  }
+
+  bool operator<(const FastMathFlags &OtherFlags) const {
+    return Flags < OtherFlags.Flags;
+  }
+
+  bool operator<=(const FastMathFlags &OtherFlags) const {
+    return Flags <= OtherFlags.Flags;
+  }
+
+  bool operator>(const FastMathFlags &OtherFlags) const {
+    return Flags > OtherFlags.Flags;
+  }
+
+  bool operator>=(const FastMathFlags &OtherFlags) const {
+    return Flags >= OtherFlags.Flags;
+  }
 };
 
 /// Utility class for floating point operations which can have
 /// information about relaxed accuracy requirements attached to them.
 class FPMathOperator : public Operator {
-private:
+  BEGIN_VALUE_SUBCLASS_DATA(FPMathOperator)
+    ADD_VALUE_SUBCLASS_BITFIELD(unsigned, 7, Flags)
+    END_VALUE_SUBCLASS_DATA()
+
   friend class Instruction;
 
   /// 'Fast' means all bits are set.
   void setFast(bool B) {
     setHasAllowReassoc(B);
     setHasNoNaNs(B);
     setHasNoInfs(B);
     setHasNoSignedZeros(B);
     setHasAllowReciprocal(B);
     setHasAllowContract(B);
     setHasApproxFunc(B);
   }
 
   void setHasAllowReassoc(bool B) {
-    SubclassOptionalData =
-    (SubclassOptionalData & ~FastMathFlags::AllowReassoc) |
+    ValueSubclassData().Flags =
+        (ValueSubclassData().Flags & ~FastMathFlags::AllowReassoc) |
         (B * FastMathFlags::AllowReassoc);
   }
 
   void setHasNoNaNs(bool B) {
-    SubclassOptionalData =
-      (SubclassOptionalData & ~FastMathFlags::NoNaNs) |
+    ValueSubclassData().Flags =
+        (ValueSubclassData().Flags & ~FastMathFlags::NoNaNs) |
         (B * FastMathFlags::NoNaNs);
   }
 
   void setHasNoInfs(bool B) {
-    SubclassOptionalData =
-      (SubclassOptionalData & ~FastMathFlags::NoInfs) |
+    ValueSubclassData().Flags =
+        (ValueSubclassData().Flags & ~FastMathFlags::NoInfs) |
         (B * FastMathFlags::NoInfs);
   }
 
   void setHasNoSignedZeros(bool B) {
-    SubclassOptionalData =
-      (SubclassOptionalData & ~FastMathFlags::NoSignedZeros) |
+    ValueSubclassData().Flags =
+        (ValueSubclassData().Flags & ~FastMathFlags::NoSignedZeros) |
         (B * FastMathFlags::NoSignedZeros);
   }
 
   void setHasAllowReciprocal(bool B) {
-    SubclassOptionalData =
-      (SubclassOptionalData & ~FastMathFlags::AllowReciprocal) |
+    ValueSubclassData().Flags =
+        (ValueSubclassData().Flags & ~FastMathFlags::AllowReciprocal) |
         (B * FastMathFlags::AllowReciprocal);
   }
 
   void setHasAllowContract(bool B) {
-    SubclassOptionalData =
-        (SubclassOptionalData & ~FastMathFlags::AllowContract) |
+    ValueSubclassData().Flags =
+        (ValueSubclassData().Flags & ~FastMathFlags::AllowContract) |
         (B * FastMathFlags::AllowContract);
   }
 
   void setHasApproxFunc(bool B) {
-    SubclassOptionalData =
-        (SubclassOptionalData & ~FastMathFlags::ApproxFunc) |
+    ValueSubclassData().Flags =
+        (ValueSubclassData().Flags & ~FastMathFlags::ApproxFunc) |
         (B * FastMathFlags::ApproxFunc);
   }
 
   /// Convenience function for setting multiple fast-math flags.
   /// FMF is a mask of the bits to set.
   void setFastMathFlags(FastMathFlags FMF) {
-    SubclassOptionalData |= FMF.Flags;
+    ValueSubclassData().Flags |= FMF.Flags;
   }
 
   /// Convenience function for copying all fast-math flags.
   /// All values in FMF are transferred to this operator.
   void copyFastMathFlags(FastMathFlags FMF) {
-    SubclassOptionalData = FMF.Flags;
+    ValueSubclassData().Flags = FMF.Flags;
   }
 
 public:
   /// Test if this operation allows all non-strict floating-point transforms.
   bool isFast() const {
-    return ((SubclassOptionalData & FastMathFlags::AllowReassoc) != 0 &&
-            (SubclassOptionalData & FastMathFlags::NoNaNs) != 0 &&
-            (SubclassOptionalData & FastMathFlags::NoInfs) != 0 &&
-            (SubclassOptionalData & FastMathFlags::NoSignedZeros) != 0 &&
-            (SubclassOptionalData & FastMathFlags::AllowReciprocal) != 0 &&
-            (SubclassOptionalData & FastMathFlags::AllowContract) != 0 &&
-            (SubclassOptionalData & FastMathFlags::ApproxFunc) != 0);
+    const unsigned AllowAllMask =
+        FastMathFlags::AllowReassoc    |
+        FastMathFlags::NoNaNs          |
+        FastMathFlags::NoInfs          |
+        FastMathFlags::NoSignedZeros   |
+        FastMathFlags::AllowReciprocal |
+        FastMathFlags::AllowContract   |
+        FastMathFlags::ApproxFunc;
+    return (ValueSubclassData().Flags & AllowAllMask) == AllowAllMask;
   }
 
   /// Test if this operation may be simplified with reassociative transforms.
   bool hasAllowReassoc() const {
-    return (SubclassOptionalData & FastMathFlags::AllowReassoc) != 0;
+    return (ValueSubclassData().Flags & FastMathFlags::AllowReassoc) != 0;
   }
 
   /// Test if this operation's arguments and results are assumed not-NaN.
   bool hasNoNaNs() const {
-    return (SubclassOptionalData & FastMathFlags::NoNaNs) != 0;
+    return (ValueSubclassData().Flags & FastMathFlags::NoNaNs) != 0;
   }
 
   /// Test if this operation's arguments and results are assumed not-infinite.
   bool hasNoInfs() const {
-    return (SubclassOptionalData & FastMathFlags::NoInfs) != 0;
+    return (ValueSubclassData().Flags & FastMathFlags::NoInfs) != 0;
   }
 
   /// Test if this operation can ignore the sign of zero.
   bool hasNoSignedZeros() const {
-    return (SubclassOptionalData & FastMathFlags::NoSignedZeros) != 0;
+    return (ValueSubclassData().Flags & FastMathFlags::NoSignedZeros) != 0;
   }
 
   /// Test if this operation can use reciprocal multiply instead of division.
   bool hasAllowReciprocal() const {
-    return (SubclassOptionalData & FastMathFlags::AllowReciprocal) != 0;
+    return (ValueSubclassData().Flags & FastMathFlags::AllowReciprocal) != 0;
   }
 
   /// Test if this operation can be floating-point contracted (FMA).
   bool hasAllowContract() const {
-    return (SubclassOptionalData & FastMathFlags::AllowContract) != 0;
+    return (ValueSubclassData().Flags & FastMathFlags::AllowContract) != 0;
   }
 
   /// Test if this operation allows approximations of math library functions or
   /// intrinsics.
   bool hasApproxFunc() const {
-    return (SubclassOptionalData & FastMathFlags::ApproxFunc) != 0;
+    return (ValueSubclassData().Flags & FastMathFlags::ApproxFunc) != 0;
   }
 
   /// Convenience function for getting all the fast-math flags
   FastMathFlags getFastMathFlags() const {
-    return FastMathFlags(SubclassOptionalData);
+    return FastMathFlags(ValueSubclassData().Flags);
   }
 
   /// Get the maximum error permitted by this operation in ULPs. An accuracy of
   /// 0.0 means that the operation should be performed with the default
   /// precision.
   float getFPAccuracy() const;
 
   static bool classof(const Value *V) {

 
 class ZExtOperator : public ConcreteOperator<Operator, Instruction::ZExt> {};
 
 class GEPOperator
   : public ConcreteOperator<Operator, Instruction::GetElementPtr> {
   friend class GetElementPtrInst;
   friend class ConstantExpr;
 
+  BEGIN_VALUE_SUBCLASS_DATA(GEPOperator)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool,     1, IsInBounds)
+    ADD_VALUE_SUBCLASS_BITFIELD(unsigned, 6, InRangeIndex)
+    END_VALUE_SUBCLASS_DATA()
+
   enum {
     IsInBounds = (1 << 0),
     // InRangeIndex: bits 1-6
   };
 
-  void setIsInBounds(bool B) {
-    SubclassOptionalData =
-      (SubclassOptionalData & ~IsInBounds) | (B * IsInBounds);
-  }
+  void setIsInBounds(bool B) { ValueSubclassData().IsInBounds = B; }
 
 public:
   /// Test whether this is an inbounds GEP, as defined by LangRef.html.
-  bool isInBounds() const {
-    return SubclassOptionalData & IsInBounds;
-  }
+  bool isInBounds() const { return ValueSubclassData().IsInBounds; }
 
   /// Returns the offset of the index with an inrange attachment, or None if
   /// none.
   Optional<unsigned> getInRangeIndex() const {
-    if (SubclassOptionalData >> 1 == 0) return None;
-    return (SubclassOptionalData >> 1) - 1;
+    unsigned InRangeIndex = ValueSubclassData().InRangeIndex;
+    if (InRangeIndex == 0) return None;
+    return InRangeIndex - 1;
   }
 
   inline op_iterator       idx_begin()       { return op_begin()+1; }
   inline const_op_iterator idx_begin() const { return op_begin()+1; }
   inline op_iterator       idx_end()         { return op_end(); }
   inline const_op_iterator idx_end()   const { return op_end(); }
 
   Value *getPointerOperand() {

llvm/include/llvm/IR/Type.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_TYPE_H
 #define LLVM_IR_TYPE_H
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SubclassData.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TypeSize.h"
 #include <cassert>
 #include <cstdint>
 #include <iterator>
enum TypeID {
     PointerTyID,     ///< 15: Pointers
     VectorTyID       ///< 16: SIMD 'packed' format, or other vector type
   };
 
 private:
   /// This refers to the LLVMContext in which this type was uniqued.
   LLVMContext &Context;
 
-  TypeID   ID : 8;            // The current base type of this type.
-  unsigned SubclassData : 24; // Space for subclasses to store data.
-                              // Note that this should be synchronized with
-                              // MAX_INT_BITS value in IntegerType class.
+  BEGIN_PACKED_BITFIELDS(32)
+    ADD_PACKED_BITFIELD(TypeID, 8, ID) // The current base type of this type.
+    END_PACKED_BITFIELDS();
 
 protected:
   friend class LLVMContextImpl;
 
-  explicit Type(LLVMContext &C, TypeID tid)
-    : Context(C), ID(tid), SubclassData(0) {}
+  explicit Type(LLVMContext &C, TypeID tid) : Context(C) { ID = tid; }
   ~Type() = default;
 
-  unsigned getSubclassData() const { return SubclassData; }
-
-  void setSubclassData(unsigned val) {
-    SubclassData = val;
-    // Ensure we don't have any accidental truncation.
-    assert(getSubclassData() == val && "Subclass data too large for field");
-  }
+  DECLARE_SUBCLASS_DATA(Type)
 
   /// Keeps track of how many Type*'s there are in the ContainedTys list.
   unsigned NumContainedTys = 0;
 
   /// A pointer to the array of Types contained by this Type. For example, this
   /// includes the arguments of a function type, the elements of a structure,
   /// the pointee of a pointer, the element type of an array, etc. This pointer
   /// may be 0 for types that don't contain other types (Integer, Double,

 inline Type **unwrap(LLVMTypeRef* Tys) {
   return reinterpret_cast<Type**>(Tys);
 }
 
 inline LLVMTypeRef *wrap(Type **Tys) {
   return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
 }
 
+#define BEGIN_TYPE_SUBCLASS_DATA(Class)                                        \
+  BEGIN_SUBCLASS_DATA(Type, Class)
+
+#define ADD_TYPE_SUBCLASS_BITFIELD(Ty, Bits, Name)                             \
+  ADD_SUBCLASS_BITFIELD(Type, Ty, Bits, Name)
+
+#define END_TYPE_SUBCLASS_DATA()                                               \
+  END_SUBCLASS_DATA(Type)
+
 } // end namespace llvm
 
 #endif // LLVM_IR_TYPE_H

llvm/include/llvm/IR/User.h

 class User : public Value {
   template <unsigned>
   friend struct HungoffOperandTraits;
 
   LLVM_ATTRIBUTE_ALWAYS_INLINE inline static void *
   allocateFixedOperandUser(size_t, unsigned, unsigned);
 
 protected:
+  BEGIN_VALUE_SUBCLASS_DATA(User)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool,      -1, HasDescriptor)
+    ADD_VALUE_SUBCLASS_BITFIELD(bool,      -1, HasHungOffUses)
+    ADD_VALUE_SUBCLASS_BITFIELD(unsigned, -30, NumOperands)
+    END_VALUE_SUBCLASS_DATA()
+
+  static constexpr unsigned SubclassOptionalDataMaxBitSize = 7;
+  static constexpr unsigned SubclassOptionalDataMinBitOffset =
+      bit_offsetof<TYPEOF_SUBCLASS_BITFIELD(Value, NumOperands)>() -
+      SubclassOptionalDataMaxBitSize;
+
   /// Allocate a User with an operand pointer co-allocated.
   ///
   /// This is used for subclasses which need to allocate a variable number
   /// of operands, ie, 'hung off uses'.
   void *operator new(size_t Size);
 
   /// Allocate a User with the operands co-allocated.
   ///
   /// This is used for subclasses which have a fixed number of operands.
   void *operator new(size_t Size, unsigned Us);
 
   /// Allocate a User with the operands co-allocated.  If DescBytes is non-zero
   /// then allocate an additional DescBytes bytes before the operands. These
   /// bytes can be accessed by calling getDescriptor.
   ///
   /// DescBytes needs to be divisible by sizeof(void *).  The allocated
   /// descriptor, if any, is aligned to sizeof(void *) bytes.
   ///
   /// This is used for subclasses which have a fixed number of operands.
   void *operator new(size_t Size, unsigned Us, unsigned DescBytes);
 
-  User(Type *ty, unsigned vty, Use *, unsigned NumOps)
-      : Value(ty, vty) {
-    assert(NumOps < (1u << NumUserOperandsBits) && "Too many operands");
-    NumUserOperands = NumOps;
-    // If we have hung off uses, then the operand list should initially be
-    // null.
-    assert((!HasHungOffUses || !getOperandList()) &&
-           "Error in initializing hung off uses for User");
+  User(Type* ty, unsigned vty, Use*, unsigned NumOps);
+
+  void setNumOperands(unsigned NumOps) {
+    ValueSubclassData().NumOperands = NumOps;
   }
 
+  bool hasHungOffUses() const { return ValueSubclassData().HasHungOffUses; }
+
   /// Allocate the array of Uses, followed by a pointer
   /// (with bottom bit set) to the User.
   /// \param IsPhi identifies callers which are phi nodes and which need
   /// N BasicBlock* allocated along with N
   void allocHungoffUses(unsigned N, bool IsPhi = false);
 
   /// Grow the number of hung off uses.  Note that allocHungoffUses
   /// should be called if there are no uses.
   void growHungoffUses(unsigned N, bool IsPhi = false);
 
 protected:
   ~User() = default; // Use deleteValue() to delete a generic Instruction.
 
 public:
   User(const User &) = delete;
 
   /// Free memory allocated for User and Use objects.
   void operator delete(void *Usr);
   /// Placement delete - required by std, called if the ctor throws.
   void operator delete(void *Usr, unsigned) {
     // Note: If a subclass manipulates the information which is required to calculate the
-    // Usr memory pointer, e.g. NumUserOperands, the operator delete of that subclass has
-    // to restore the changed information to the original value, since the dtor of that class
+    // Usr memory pointer, e.g. SubclassData1, the operator delete of that subclass has to
+    // restore the changed information to the original value, since the dtor of that class
     // is not called if the ctor fails.
     User::operator delete(Usr);
 
 #ifndef LLVM_ENABLE_EXCEPTIONS
     llvm_unreachable("Constructor throws?");
 #endif
   }
   /// Placement delete - required by std, called if the ctor throws.
   void operator delete(void *Usr, unsigned, unsigned) {
     // Note: If a subclass manipulates the information which is required to calculate the
-    // Usr memory pointer, e.g. NumUserOperands, the operator delete of that subclass has
-    // to restore the changed information to the original value, since the dtor of that class
+    // Usr memory pointer, e.g. SubclassData1, the operator delete of that subclass has to
+    // restore the changed information to the original value, since the dtor of that class
     // is not called if the ctor fails.
     User::operator delete(Usr);
 
 #ifndef LLVM_ENABLE_EXCEPTIONS
     llvm_unreachable("Constructor throws?");
 #endif
   }
 

 private:
   const Use *getHungOffOperands() const {
     return *(reinterpret_cast<const Use *const *>(this) - 1);
   }
 
   Use *&getHungOffOperands() { return *(reinterpret_cast<Use **>(this) - 1); }
 
   const Use *getIntrusiveOperands() const {
-    return reinterpret_cast<const Use *>(this) - NumUserOperands;
+    return reinterpret_cast<const Use *>(this) - getNumOperands();
   }
 
   Use *getIntrusiveOperands() {
-    return reinterpret_cast<Use *>(this) - NumUserOperands;
+    return reinterpret_cast<Use *>(this) - getNumOperands();
   }
 
   void setOperandList(Use *NewList) {
-    assert(HasHungOffUses &&
+    assert(hasHungOffUses() &&
            "Setting operand list only required for hung off uses");
     getHungOffOperands() = NewList;
   }
 
 public:
   const Use *getOperandList() const {
-    return HasHungOffUses ? getHungOffOperands() : getIntrusiveOperands();
+    return hasHungOffUses() ? getHungOffOperands() : getIntrusiveOperands();
   }
   Use *getOperandList() {
     return const_cast<Use *>(static_cast<const User *>(this)->getOperandList());
   }
 
   Value *getOperand(unsigned i) const {
-    assert(i < NumUserOperands && "getOperand() out of range!");
+    assert(i < getNumOperands() && "getOperand() out of range!");
     return getOperandList()[i];
   }
 
   void setOperand(unsigned i, Value *Val) {
-    assert(i < NumUserOperands && "setOperand() out of range!");
+    assert(i < getNumOperands() && "setOperand() out of range!");
     assert((!isa<Constant>((const Value*)this) ||
             isa<GlobalValue>((const Value*)this)) &&
            "Cannot mutate a constant with setOperand!");
     getOperandList()[i] = Val;
   }
 
   const Use &getOperandUse(unsigned i) const {
-    assert(i < NumUserOperands && "getOperandUse() out of range!");
+    assert(i < getNumOperands() && "getOperandUse() out of range!");
     return getOperandList()[i];
   }
   Use &getOperandUse(unsigned i) {
-    assert(i < NumUserOperands && "getOperandUse() out of range!");
+    assert(i < getNumOperands() && "getOperandUse() out of range!");
     return getOperandList()[i];
   }
 
-  unsigned getNumOperands() const { return NumUserOperands; }
+  unsigned getNumOperands() const { return ValueSubclassData().NumOperands; }
 
   /// Returns the descriptor co-allocated with this User instance.
   ArrayRef<const uint8_t> getDescriptor() const;
 
   /// Returns the descriptor co-allocated with this User instance.
   MutableArrayRef<uint8_t> getDescriptor();
 
   /// Set the number of operands on a GlobalVariable.
   ///
   /// GlobalVariable always allocates space for a single operands, but
   /// doesn't always use it.
   ///
   /// FIXME: As that the number of operands is used to find the start of
   /// the allocated memory in operator delete, we need to always think we have
   /// 1 operand before delete.
   void setGlobalVariableNumOperands(unsigned NumOps) {
     assert(NumOps <= 1 && "GlobalVariable can only have 0 or 1 operands");
-    NumUserOperands = NumOps;
+    setNumOperands(NumOps);
   }
 
   /// Subclasses with hung off uses need to manage the operand count
   /// themselves.  In these instances, the operand count isn't used to find the
   /// OperandList, so there's no issue in having the operand count change.
   void setNumHungOffUseOperands(unsigned NumOps) {
-    assert(HasHungOffUses && "Must have hung off uses to use this method");
-    assert(NumOps < (1u << NumUserOperandsBits) && "Too many operands");
-    NumUserOperands = NumOps;
+    assert(hasHungOffUses() && "Must have hung off uses to use this method");
+    setNumOperands(NumOps);
   }
 
   // ---------------------------------------------------------------------------
   // Operand Iterator interface...
   //
   using op_iterator = Use*;
   using const_op_iterator = const Use*;
   using op_range = iterator_range<op_iterator>;
   using const_op_range = iterator_range<const_op_iterator>;
 
   op_iterator       op_begin()       { return getOperandList(); }
   const_op_iterator op_begin() const { return getOperandList(); }
   op_iterator       op_end()         {
-    return getOperandList() + NumUserOperands;
+    return getOperandList() + getNumOperands();
   }
   const_op_iterator op_end()   const {
-    return getOperandList() + NumUserOperands;
+    return getOperandList() + getNumOperands();
   }
   op_range operands() {
     return op_range(op_begin(), op_end());
   }
   const_op_range operands() const {
     return const_op_range(op_begin(), op_end());
   }
 

 template<> struct simplify_type<User::const_op_iterator> {
   using SimpleType = /*const*/ Value*;
 
   static SimpleType getSimplifiedValue(User::const_op_iterator &Val) {
     return Val->get();
   }
 };
 
+#define ADD_VALUE_SUBCLASS_OPTIONALDATA()                                      \
+  ADD_VALUE_SUBCLASS_BITFIELD(unsigned, -int(SubclassOptionalDataMaxBitSize),  \
+                              OptionalData)                                    \
+  NEXT_OPTIONAL_DATA;                                                          \
+  static_assert(SubclassOptionalDataMinBitOffset ==                            \
+                    bit_offsetof<decltype(OptionalData)>(),                    \
+                "Invalid offset of subclass OptionalData!");                   \
+  typedef NEXT_OPTIONAL_DATA
+
 } // end namespace llvm
 
 #endif // LLVM_IR_USER_H

llvm/include/llvm/IR/Value.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_VALUE_H
 #define LLVM_IR_VALUE_H
 
 #include "llvm-c/Types.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SubclassData.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Use.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Casting.h"
 #include <cassert>
 #include <iterator>
 #include <memory>
class Value {
   // The least-significant bit of the first word of Value *must* be zero:
   //   http://www.llvm.org/docs/ProgrammersManual.html#the-waymarking-algorithm
   Type *VTy;
   Use *UseList;
 
   friend class ValueAsMetadata; // Allow access to IsUsedByMD.
   friend class ValueHandleBase;
 
-  const unsigned char SubclassID;   // Subclass identifier (for isa/dyn_cast)
-  unsigned char HasValueHandle : 1; // Has a ValueHandle pointing to this?
+  BEGIN_PACKED_BITFIELDS(64)
+    // Subclass identifier (for isa/dyn_cast)
+    ADD_PACKED_BITFIELD(unsigned, 8, SubclassID)
+    // Has a ValueHandle pointing to this?
+    ADD_PACKED_BITFIELD(bool, 1, HasValueHandle)
+    ADD_PACKED_BITFIELD(bool, 1, HasName)
+    ADD_PACKED_BITFIELD(bool, 1, IsUsedByMD)
+    END_PACKED_BITFIELDS();
 
 protected:
-  /// Hold subclass data that can be dropped.
-  ///
-  /// This member is similar to SubclassData, however it is for holding
-  /// information which may be used to aid optimization, but which may be
-  /// cleared to zero without affecting conservative interpretation.
-  unsigned char SubclassOptionalData : 7;
+  DECLARE_SUBCLASS_DATA(Value)
 
-private:
-  /// Hold arbitrary subclass data.
-  ///
-  /// This member is defined by this class, but is not used for anything.
-  /// Subclasses can use it to hold whatever state they find useful.  This
-  /// field is initialized to zero by the ctor.
-  unsigned short SubclassData;
-
-protected:
   /// The number of operands in the subclass.
   ///
   /// This member is defined by this class, but not used for anything.
   /// Subclasses can use it to store their number of operands, if they have
   /// any.
   ///
   /// This is stored here to save space in User on 64-bit hosts.  Since most
   /// instances of Value have operands, 32-bit hosts aren't significantly
   /// affected.
   ///
   /// Note, this should *NOT* be used directly by any class other than User.
   /// User uses this value to find the Use list.
-  enum : unsigned { NumUserOperandsBits = 28 };
-  unsigned NumUserOperands : NumUserOperandsBits;
   
-  // Use the same type as the bitfield above so that MSVC will pack them.
-  unsigned IsUsedByMD : 1;
-  unsigned HasName : 1;
-  unsigned HasHungOffUses : 1;
-  unsigned HasDescriptor : 1;
 
 private:
   template <typename UseT> // UseT == 'Use' or 'const Use'
   class use_iterator_impl
       : public std::iterator<std::forward_iterator_tag, UseT *> {
     friend class Value;
 
     UseT *U;
public:
     operator user_iterator_impl<const UserTy>() const {
       return user_iterator_impl<const UserTy>(*UI);
     }
 
     Use &getUse() const { return *UI; }
   };
 
 protected:
-  Value(Type *Ty, unsigned scid);
+  Value(Type *Ty, unsigned scid, uint64_t PreservedSubclassDataMask = 0);
 
   /// Value's destructor should be virtual by design, but that would require
   /// that Value and all of its subclasses have a vtable that effectively
   /// duplicates the information in the value ID. As a size optimization, the
   /// destructor has been protected, and the caller should manually call
   /// deleteValue.
   ~Value(); // Use deleteValue() to delete a generic Value.
 
#include "llvm/IR/Value.def"
   /// # there is no value with code InstructionVal (no opcode==0).
   /// # there are more possible values for the value type than in ValueTy enum.
   /// # the InstructionVal enumerator must be the highest valued enumerator in
   ///   the ValueTy enum.
   unsigned getValueID() const {
     return SubclassID;
   }
 
-  /// Return the raw optional flags value contained in this value.
-  ///
-  /// This should only be used when testing two Values for equivalence.
-  unsigned getRawSubclassOptionalData() const {
-    return SubclassOptionalData;
-  }
-
-  /// Clear the optional flags contained in this value.
-  void clearSubclassOptionalData() {
-    SubclassOptionalData = 0;
-  }
-
-  /// Check the optional flags for equality.
-  bool hasSameSubclassOptionalData(const Value *V) const {
-    return SubclassOptionalData == V->SubclassOptionalData;
-  }
-
   /// Return true if there is a value handle associated with this value.
   bool hasValueHandle() const { return HasValueHandle; }
 
   /// Return true if there is metadata referencing this value.
   bool isUsedByMetadata() const { return IsUsedByMD; }
 
   /// Return true if this value is a swifterror value.
   ///
while (true) {
         *Next = L;
         Next = &L->Next;
         L = L->Next;
       }
     }
 
     return Merged;
   }
-
-protected:
-  unsigned short getSubclassDataFromValue() const { return SubclassData; }
-  void setValueSubclassData(unsigned short D) { SubclassData = D; }
 };
 
 struct ValueDeleter { void operator()(Value *V) { V->deleteValue(); } };
 
 /// Use this instead of std::unique_ptr<Value> or std::unique_ptr<Instruction>.
 /// Those don't work because Value and Instruction's destructors are protected,
 /// aren't virtual, and won't destroy the complete object.
 using unique_value = std::unique_ptr<Value, ValueDeleter>;
#endif
   (void)Length;
   return reinterpret_cast<T**>(Vals);
 }
 
 inline LLVMValueRef *wrap(const Value **Vals) {
   return reinterpret_cast<LLVMValueRef*>(const_cast<Value**>(Vals));
 }
 
+#define BEGIN_VALUE_SUBCLASS_DATA(Class)                                       \
+  BEGIN_SUBCLASS_DATA(Value, Class)
+
+#define ADD_VALUE_SUBCLASS_BITFIELD(Type, Bits, Name)                          \
+  ADD_SUBCLASS_BITFIELD(Value, Type, Bits, Name)
+
+#define END_VALUE_SUBCLASS_DATA()                                              \
+  END_SUBCLASS_DATA(Value)
+
 } // end namespace llvm
 
 #endif // LLVM_IR_VALUE_H

llvm/include/llvm/Support/AtomicOrdering.h

 
 /// Atomic ordering for LLVM's memory model.
 ///
 /// C++ defines ordering as a lattice. LLVM supplements this with NotAtomic and
 /// Unordered, which are both below the C++ orders.
 ///
 /// not_atomic-->unordered-->relaxed-->release--------------->acq_rel-->seq_cst
 ///                                   \-->consume-->acquire--/
-enum class AtomicOrdering {
+enum class AtomicOrdering : unsigned {
   NotAtomic = 0,
   Unordered = 1,
   Monotonic = 2, // Equivalent to C++'s relaxed.
   // Consume = 3,  // Not specified yet.
   Acquire = 4,
   Release = 5,
   AcquireRelease = 6,
   SequentiallyConsistent = 7

llvm/include/llvm/Support/type_traits.h

 //===- llvm/Support/type_traits.h - Simplfied type traits -------*- 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 provides useful additions to the standard type_traits library.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_TYPE_TRAITS_H
 #define LLVM_SUPPORT_TYPE_TRAITS_H
 
 #include "llvm/Support/Compiler.h"
+#include <cstdint>
 #include <type_traits>
 #include <utility>
 
 namespace llvm {
 
 
 /// Metafunction that determines whether the given type is either an
 /// integral type or an enumeration type, including enum classes.
public:
   static const bool value =
       !std::is_class<UnderlyingT>::value && // Filter conversion operators.
       !std::is_pointer<UnderlyingT>::value &&
       !std::is_floating_point<UnderlyingT>::value &&
       (std::is_enum<UnderlyingT>::value ||
        std::is_convertible<UnderlyingT, unsigned long long>::value);
 };
 
+template <size_t BitCount, bool IsSigned = false> struct smallest_integral {
+  using type = typename std::conditional<
+      BitCount <= 8, typename std::conditional<IsSigned, int8_t, uint8_t>::type,
+      typename std::conditional<
+          BitCount <= 16,
+          typename std::conditional<IsSigned, int16_t, uint16_t>::type,
+          typename std::conditional<
+              BitCount <= 32,
+              typename std::conditional<IsSigned, int32_t, uint32_t>::type,
+              typename std::conditional<
+                  BitCount <= 64,
+                  typename std::conditional<IsSigned, int64_t, uint64_t>::type,
+                  void>::type>::type>::type>::type;
+};
+
 /// If T is a pointer, just return it. If it is not, return T&.
 template<typename T, typename Enable = void>
 struct add_lvalue_reference_if_not_pointer { using type = T &; };
 
 template <typename T>
 struct add_lvalue_reference_if_not_pointer<
     T, typename std::enable_if<std::is_pointer<T>::value>::type> {
   using type = T;

llvm/include/llvm/Transforms/Utils/FunctionComparator.h

protected:
   /// On each stage below, we do comparison between some left and right
   /// operation parts. If parts are non-equal, we assign parts comparison
   /// result to the operation comparison result and exit from method.
   /// Otherwise we proceed to the next stage.
   /// Stages:
   /// 1. Operations opcodes. Compared as numbers.
   /// 2. Number of operands.
   /// 3. Operation types. Compared with cmpType method.
-  /// 4. Compare operation subclass optional data as stream of bytes:
+  /// 4. Compare operator data as stream of bytes:
   /// just convert it to integers and call cmpNumbers.
   /// 5. Compare in operation operand types with cmpType in
   /// most significant operand first order.
   /// 6. Last stage. Check operations for some specific attributes.
   /// For example, for Load it would be:
   /// 6.1.Load: volatile (as boolean flag)
   /// 6.2.Load: alignment (as integer numbers)
   /// 6.3.Load: ordering (as underlying enum class value)
protected:
   int cmpAPFloats(const APFloat &L, const APFloat &R) const;
   int cmpMem(StringRef L, StringRef R) const;
 
   // The two functions undergoing comparison.
   const Function *FnL, *FnR;
 
 private:
   int cmpOrderings(AtomicOrdering L, AtomicOrdering R) const;
+  int cmpFastMathFlags(FastMathFlags L, FastMathFlags R) const;
   int cmpInlineAsm(const InlineAsm *L, const InlineAsm *R) const;
   int cmpAttrs(const AttributeList L, const AttributeList R) const;
   int cmpRangeMetadata(const MDNode *L, const MDNode *R) const;
   int cmpOperandBundlesSchema(const Instruction *L, const Instruction *R) const;
 
   /// Compare two GEPs for equivalent pointer arithmetic.
   /// Parts to be compared for each comparison stage,
   /// most significant stage first:

llvm/lib/IR/Constants.cpp

return ConstantExpr::getGetElementPtr(
         GEPO->isInBounds(), GEPO->getInRangeIndex(), OnlyIfReducedTy);
   }
   case Instruction::ICmp:
   case Instruction::FCmp:
     return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1],
                                     OnlyIfReducedTy);
   default:
     assert(getNumOperands() == 2 && "Must be binary operator?");
-    return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData,
-                             OnlyIfReducedTy);
+    return ConstantExpr::get(getOpcode(), Ops[0], Ops[1],
+                             ValueSubclassData().OptionalData, OnlyIfReducedTy);
   }
 }
 
 
 //===----------------------------------------------------------------------===//
 //                      isValueValidForType implementations
 
 bool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) {
assert((!Idxs[i]->getType()->isVectorTy() ||
            "getelementptr index type missmatch");
 
     Constant *Idx = cast<Constant>(Idxs[i]);
     if (NumVecElts && !Idxs[i]->getType()->isVectorTy())
       Idx = ConstantVector::getSplat(NumVecElts, Idx);
     ArgVec.push_back(Idx);
   }
 
-  unsigned SubClassOptionalData = InBounds ? GEPOperator::IsInBounds : 0;
+  unsigned OptionalData = InBounds ? GEPOperator::IsInBounds : 0;
   if (InRangeIndex && *InRangeIndex < 63)
-    SubClassOptionalData |= (*InRangeIndex + 1) << 1;
+    OptionalData |= (*InRangeIndex + 1) << 1;
   const ConstantExprKeyType Key(Instruction::GetElementPtr, ArgVec, 0,
-                                SubClassOptionalData, None, Ty);
+                                OptionalData, None, Ty);
 
   LLVMContextImpl *pImpl = C->getContext().pImpl;
   return pImpl->ExprConstants.getOrCreate(ReqTy, Key);
 }
 
 Constant *ConstantExpr::getICmp(unsigned short pred, Constant *LHS,
                                 Constant *RHS, bool OnlyIfReduced) {
   assert(LHS->getType() == RHS->getType());
Instruction *ConstantExpr::getAsInstruction() const {
   case Instruction::FNeg:
     return UnaryOperator::Create((Instruction::UnaryOps)getOpcode(), Ops[0]);
   default:
     assert(getNumOperands() == 2 && "Must be binary operator?");
     BinaryOperator *BO =
       BinaryOperator::Create((Instruction::BinaryOps)getOpcode(),
                              Ops[0], Ops[1]);
     if (isa<OverflowingBinaryOperator>(BO)) {
-      BO->setHasNoUnsignedWrap(SubclassOptionalData &
+      BO->setHasNoUnsignedWrap(ValueSubclassData().OptionalData &
                                OverflowingBinaryOperator::NoUnsignedWrap);
-      BO->setHasNoSignedWrap(SubclassOptionalData &
+      BO->setHasNoSignedWrap(ValueSubclassData().OptionalData &
                              OverflowingBinaryOperator::NoSignedWrap);
     }
     if (isa<PossiblyExactOperator>(BO))
-      BO->setIsExact(SubclassOptionalData & PossiblyExactOperator::IsExact);
+      BO->setIsExact(ValueSubclassData().OptionalData &
+                     PossiblyExactOperator::IsExact);
     return BO;
   }
 }

llvm/lib/IR/ConstantsContext.h

 /// behind the scenes to implement binary constant exprs.
 class BinaryConstantExpr : public ConstantExpr {
 public:
   BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2,
                      unsigned Flags)
     : ConstantExpr(C1->getType(), Opcode, &Op<0>(), 2) {
     Op<0>() = C1;
     Op<1>() = C2;
-    SubclassOptionalData = Flags;
+    ValueSubclassData().OptionalData = Flags;
   }
 
   // allocate space for exactly two operands
   void *operator new(size_t s) {
     return User::operator new(s, 2);
   }
 
   /// Transparently provide more efficient getOperand methods.
GetElementPtrConstantExpr(Type *SrcElementTy, Constant *C,
                             ArrayRef<Constant *> IdxList, Type *DestTy);
 
 public:
   static GetElementPtrConstantExpr *Create(Type *SrcElementTy, Constant *C,
                                            ArrayRef<Constant *> IdxList,
                                            Type *DestTy, unsigned Flags) {
     GetElementPtrConstantExpr *Result = new (IdxList.size() + 1)
         GetElementPtrConstantExpr(SrcElementTy, C, IdxList, DestTy);
-    Result->SubclassOptionalData = Flags;
+    Result->ValueSubclassData().OptionalData = Flags;
     return Result;
   }
 
   Type *getSourceElementType() const;
   Type *getResultElementType() const;
 
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
ConstantExprKeyType(unsigned Opcode, ArrayRef<Constant *> Ops,
                       ArrayRef<unsigned> Indexes = None,
                       Type *ExplicitTy = nullptr)
       : Opcode(Opcode), SubclassOptionalData(SubclassOptionalData),
         SubclassData(SubclassData), Ops(Ops), Indexes(Indexes),
         ExplicitTy(ExplicitTy) {}
 
   ConstantExprKeyType(ArrayRef<Constant *> Operands, const ConstantExpr *CE)
       : Opcode(CE->getOpcode()),
-        SubclassOptionalData(CE->getRawSubclassOptionalData()),
+        SubclassOptionalData(CE->ValueSubclassData().OptionalData),
         SubclassData(CE->isCompare() ? CE->getPredicate() : 0), Ops(Operands),
         Indexes(CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()),
         ExplicitTy(nullptr) {}
 
   ConstantExprKeyType(const ConstantExpr *CE,
                       SmallVectorImpl<Constant *> &Storage)
       : Opcode(CE->getOpcode()),
-        SubclassOptionalData(CE->getRawSubclassOptionalData()),
+        SubclassOptionalData(CE->ValueSubclassData().OptionalData),
         SubclassData(CE->isCompare() ? CE->getPredicate() : 0),
         Indexes(CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()),
         ExplicitTy(nullptr) {
     assert(Storage.empty() && "Expected empty storage");
     for (unsigned I = 0, E = CE->getNumOperands(); I != E; ++I)
       Storage.push_back(CE->getOperand(I));
     Ops = Storage;
   }
 
   bool operator==(const ConstantExprKeyType &X) const {
     return Opcode == X.Opcode && SubclassData == X.SubclassData &&
            SubclassOptionalData == X.SubclassOptionalData && Ops == X.Ops &&
            Indexes == X.Indexes;
   }
 
   bool operator==(const ConstantExpr *CE) const {
     if (Opcode != CE->getOpcode())
       return false;
-    if (SubclassOptionalData != CE->getRawSubclassOptionalData())
+    if (SubclassOptionalData != CE->ValueSubclassData().OptionalData)
       return false;
     if (Ops.size() != CE->getNumOperands())
       return false;
     if (SubclassData != (CE->isCompare() ? CE->getPredicate() : 0))
       return false;
     for (unsigned I = 0, E = Ops.size(); I != E; ++I)
       if (Ops[I] != CE->getOperand(I))
         return false;

llvm/lib/IR/Function.cpp

 Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
                    const Twine &name, Module *ParentModule)
     : GlobalObject(Ty, Value::FunctionVal,
                    OperandTraits<Function>::op_begin(this), 0, Linkage, name,
                    computeAddrSpace(AddrSpace, ParentModule)),
       NumArgs(Ty->getNumParams()) {
   assert(FunctionType::isValidReturnType(getReturnType()) &&
          "invalid return type");
-  setGlobalObjectSubClassData(0);
 
   // We only need a symbol table for a function if the context keeps value names
   if (!getContext().shouldDiscardValueNames())
     SymTab = std::make_unique<ValueSymbolTable>();
 
   // If the function has arguments, mark them as lazily built.
   if (Ty->getNumParams())
-    setValueSubclassData(1);   // Set the "has lazy arguments" bit.
+    ValueSubclassData().HasLazyArguments = true;
 
   if (ParentModule)
     ParentModule->getFunctionList().push_back(this);
 
   HasLLVMReservedName = getName().startswith("llvm.");
   // Ensure intrinsics have the right parameter attributes.
   // Note, the IntID field will have been set in Value::setName if this function
   // name is a valid intrinsic ID.
if (NumArgs > 0) {
     for (unsigned i = 0, e = NumArgs; i != e; ++i) {
       Type *ArgTy = FT->getParamType(i);
       assert(!ArgTy->isVoidTy() && "Cannot have void typed arguments!");
       new (Arguments + i) Argument(ArgTy, "", const_cast<Function *>(this), i);
     }
   }
 
   // Clear the lazy arguments bit.
-  unsigned SDC = getSubclassDataFromValue();
-  SDC &= ~(1 << 0);
-  const_cast<Function*>(this)->setValueSubclassData(SDC);
+  const_cast<Function *>(this)->ValueSubclassData().HasLazyArguments = false;
   assert(!hasLazyArguments());
 }
 
 static MutableArrayRef<Argument> makeArgArray(Argument *Args, size_t Count) {
   return MutableArrayRef<Argument>(Args, Count);
 }
 
 void Function::clearArguments() {
void Function::stealArgumentListFrom(Function &Src) {
   assert(isDeclaration() && "Expected no references to current arguments");
 
   // Drop the current arguments, if any, and set the lazy argument bit.
   if (!hasLazyArguments()) {
     assert(llvm::all_of(makeArgArray(Arguments, NumArgs),
                         [](const Argument &A) { return A.use_empty(); }) &&
            "Expected arguments to be unused in declaration");
     clearArguments();
-    setValueSubclassData(getSubclassDataFromValue() | (1 << 0));
+    ValueSubclassData().HasLazyArguments = true;
   }
 
   // Nothing to steal if Src has lazy arguments.
   if (Src.hasLazyArguments())
     return;
 
   // Steal arguments from Src, and fix the lazy argument bits.
   assert(arg_size() == Src.arg_size());
   Arguments = Src.Arguments;
   Src.Arguments = nullptr;
   for (Argument &A : makeArgArray(Arguments, NumArgs)) {
     // FIXME: This does the work of transferNodesFromList inefficiently.
     SmallString<128> Name;
     if (A.hasName())
       Name = A.getName();
     if (!Name.empty())
       A.setName("");
     A.setParent(this);
     if (!Name.empty())
       A.setName(Name);
   }
 
-  setValueSubclassData(getSubclassDataFromValue() & ~(1 << 0));
-  assert(!hasLazyArguments());
-  Src.setValueSubclassData(Src.getSubclassDataFromValue() | (1 << 0));
+  ValueSubclassData().HasLazyArguments = false;
+  Src.ValueSubclassData().HasLazyArguments = true;
 }
 
 // dropAllReferences() - This function causes all the subinstructions to "let
 // go" of all references that they are maintaining.  This allows one to
 // 'delete' a whole class at a time, even though there may be circular
 // references... first all references are dropped, and all use counts go to
 // zero.  Then everything is deleted for real.  Note that no operations are
 // valid on an object that has "dropped all references", except operator
void Function::dropAllReferences() {
   // blockaddresses, but BasicBlock's destructor takes care of those.
   while (!BasicBlocks.empty())
     BasicBlocks.begin()->eraseFromParent();
 
   // Drop uses of any optional data (real or placeholder).
   if (getNumOperands()) {
     User::dropAllReferences();
     setNumHungOffUseOperands(0);
-    setValueSubclassData(getSubclassDataFromValue() & ~0xe);
+    ValueSubclassData().HasPrefixData = false;
+    ValueSubclassData().HasPrologueData = false;
+    ValueSubclassData().HasPersonalityFn = false;
   }
 
   // Metadata is stored in a side-table.
   clearMetadata();
 }
 
 void Function::addAttribute(unsigned i, Attribute::AttrKind Kind) {
   AttributeList PAL = getAttributes();

 }
 
 const std::string &Function::getGC() const {
   assert(hasGC() && "Function has no collector");
   return getContext().getGC(*this);
 }
 
 void Function::setGC(std::string Str) {
-  setValueSubclassDataBit(14, !Str.empty());
+  ValueSubclassData().HasGC = !Str.empty();
   getContext().setGC(*this, std::move(Str));
 }
 
 void Function::clearGC() {
   if (!hasGC())
     return;
   getContext().deleteGC(*this);
-  setValueSubclassDataBit(14, false);
+  ValueSubclassData().HasGC = false;
 }
 
 /// Copy all additional attributes (those not needed to create a Function) from
 /// the Function Src to this one.
 void Function::copyAttributesFrom(const Function *Src) {
   GlobalObject::copyAttributesFrom(Src);
   setCallingConv(Src->getCallingConv());
   setAttributes(Src->getAttributes());

 
 Constant *Function::getPersonalityFn() const {
   assert(hasPersonalityFn() && getNumOperands());
   return cast<Constant>(Op<0>());
 }
 
 void Function::setPersonalityFn(Constant *Fn) {
   setHungoffOperand<0>(Fn);
-  setValueSubclassDataBit(3, Fn != nullptr);
+  ValueSubclassData().HasPersonalityFn = Fn != nullptr;
 }
 
 Constant *Function::getPrefixData() const {
   assert(hasPrefixData() && getNumOperands());
   return cast<Constant>(Op<1>());
 }
 
 void Function::setPrefixData(Constant *PrefixData) {
   setHungoffOperand<1>(PrefixData);
-  setValueSubclassDataBit(1, PrefixData != nullptr);
+  ValueSubclassData().HasPrefixData = PrefixData != nullptr;
 }
 
 Constant *Function::getPrologueData() const {
   assert(hasPrologueData() && getNumOperands());
   return cast<Constant>(Op<2>());
 }
 
 void Function::setPrologueData(Constant *PrologueData) {
   setHungoffOperand<2>(PrologueData);
-  setValueSubclassDataBit(2, PrologueData != nullptr);
+  ValueSubclassData().HasPrologueData = PrologueData != nullptr;
 }
 
 void Function::allocHungoffUselist() {
   // If we've already allocated a uselist, stop here.
   if (getNumOperands())
     return;
 
   allocHungoffUses(3, /*IsPhi=*/ false);
if (C) {
     allocHungoffUselist();
     Op<Idx>().set(C);
   } else if (getNumOperands()) {
     Op<Idx>().set(
         ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0)));
   }
 }
 
-void Function::setValueSubclassDataBit(unsigned Bit, bool On) {
-  assert(Bit < 16 && "SubclassData contains only 16 bits");
-  if (On)
-    setValueSubclassData(getSubclassDataFromValue() | (1 << Bit));
-  else
-    setValueSubclassData(getSubclassDataFromValue() & ~(1 << Bit));
-}
-
 void Function::setEntryCount(ProfileCount Count,
                              const DenseSet<GlobalValue::GUID> *S) {
   assert(Count.hasValue());
 #if !defined(NDEBUG)
   auto PrevCount = getEntryCount();
   assert(!PrevCount.hasValue() || PrevCount.getType() == Count.getType());
 #endif
 

llvm/lib/IR/Globals.cpp

 
 void GlobalObject::setAlignment(unsigned Align) {
   setAlignment(MaybeAlign(Align));
 }
 
 void GlobalObject::setAlignment(MaybeAlign Align) {
   assert((!Align || Align <= MaximumAlignment) &&
          "Alignment is greater than MaximumAlignment!");
-  unsigned AlignmentData = encode(Align);
-  unsigned OldData = getGlobalValueSubClassData();
-  setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
+  GlobalValueSubclassData().EncodedAlignment = encode(Align);
   assert(MaybeAlign(getAlignment()) == Align &&
          "Alignment representation error!");
 }
 
 void GlobalObject::copyAttributesFrom(const GlobalObject *Src) {
   GlobalValue::copyAttributesFrom(Src);
   setAlignment(MaybeAlign(Src->getAlignment()));
   setSection(Src->getSection());
if (!hasSection() && S.empty())
     return;
 
   // Get or create a stable section name string and put it in the table in the
   // context.
   if (!S.empty())
     S = getContext().pImpl->Saver.save(S);
   getContext().pImpl->GlobalObjectSections[this] = S;
 
-  // Update the HasSectionHashEntryBit. Setting the section to the empty string
-  // means this global no longer has a section.
-  setGlobalObjectFlag(HasSectionHashEntryBit, !S.empty());
+  // Update HasSectionHashEntry. Setting the section to the empty string means
+  // this global no longer has a section.
+  GlobalValueSubclassData().HasSectionHashEntry = !S.empty();
 }
 
 bool GlobalValue::isDeclaration() const {
   // Globals are definitions if they have an initializer.
   if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
     return GV->getNumOperands() == 0;
 
   // Functions are definitions if they have a body.

llvm/lib/IR/Instruction.cpp

 //===-- Instruction.cpp - Implement the Instruction class -----------------===//
 //
 // 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 implements the Instruction class for the IR library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Instruction.h"
-#include "llvm/IR/IntrinsicInst.h"
-#include "llvm/ADT/DenseSet.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Type.h"
 using namespace llvm;
 
 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
                          Instruction *InsertBefore)
   : User(ty, Value::InstructionVal + it, Ops, NumOps), Parent(nullptr) {
return RMWI->getOperation() == cast<AtomicRMWInst>(I2)->getOperation() &&
            RMWI->isVolatile() == cast<AtomicRMWInst>(I2)->isVolatile() &&
            RMWI->getOrdering() == cast<AtomicRMWInst>(I2)->getOrdering() &&
            RMWI->getSyncScopeID() == cast<AtomicRMWInst>(I2)->getSyncScopeID();
 
   return true;
 }
 
 bool Instruction::isIdenticalTo(const Instruction *I) const {
-  return isIdenticalToWhenDefined(I) &&
-         SubclassOptionalData == I->SubclassOptionalData;
+  if (!isIdenticalToWhenDefined(I))
+    return false;
+
+  if (auto *OBO = dyn_cast<OverflowingBinaryOperator>(this))
+    return OBO->hasNoUnsignedWrap() == I->hasNoUnsignedWrap() &&
+           OBO->hasNoSignedWrap() == I->hasNoSignedWrap();
+
+  if (auto *PEO = dyn_cast<PossiblyExactOperator>(this))
+    return PEO->isExact() == I->isExact();
+
+  if (auto *FPMO = dyn_cast<FPMathOperator>(this))
+    return FPMO->getFastMathFlags() == I->getFastMathFlags();
+
+  if (auto *GEPO = dyn_cast<GEPOperator>(this))
+    return GEPO->isInBounds() == cast<GEPOperator>(I)->isInBounds() &&
+           GEPO->getInRangeIndex() == cast<GEPOperator>(I)->getInRangeIndex();
+
+  return false;
 }
 
 bool Instruction::isIdenticalToWhenDefined(const Instruction *I) const {
   if (getOpcode() != I->getOpcode() ||
       getNumOperands() != I->getNumOperands() ||
       getType() != I->getType())
     return false;
 

 #define HANDLE_INST(num, opc, clas)                                            \
   case Instruction::opc:                                                       \
     New = cast<clas>(this)->cloneImpl();                                       \
     break;
 #include "llvm/IR/Instruction.def"
 #undef HANDLE_INST
   }
 
-  New->SubclassOptionalData = SubclassOptionalData;
   New->copyMetadata(*this);
   return New;
 }
 
 void Instruction::setProfWeight(uint64_t W) {
   assert(isa<CallBase>(this) &&
          "Can only set weights for call like instructions");
   SmallVector<uint32_t, 1> Weights;
   Weights.push_back(W);
   MDBuilder MDB(getContext());
   setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
 }

llvm/lib/IR/Instructions.cpp

 //===----------------------------------------------------------------------===//
 
 PHINode::PHINode(const PHINode &PN)
     : Instruction(PN.getType(), Instruction::PHI, nullptr, PN.getNumOperands()),
       ReservedSpace(PN.getNumOperands()) {
   allocHungoffUses(PN.getNumOperands());
   std::copy(PN.op_begin(), PN.op_end(), op_begin());
   std::copy(PN.block_begin(), PN.block_end(), block_begin());
-  SubclassOptionalData = PN.SubclassOptionalData;
+  ValueSubclassData().OptionalData = PN.ValueSubclassData().OptionalData;
 }
 
 // removeIncomingValue - Remove an incoming value.  This is useful if a
 // predecessor basic block is deleted.
 Value *PHINode::removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty) {
   Value *Removed = getIncomingValue(Idx);
 
   // Move everything after this operand down.
: CallBase(CI.Attrs, CI.FTy, CI.getType(), Instruction::Call,
                OperandTraits<CallBase>::op_end(this) - CI.getNumOperands(),
                CI.getNumOperands()) {
   setTailCallKind(CI.getTailCallKind());
   setCallingConv(CI.getCallingConv());
 
   std::copy(CI.op_begin(), CI.op_end(), op_begin());
   std::copy(CI.bundle_op_info_begin(), CI.bundle_op_info_end(),
             bundle_op_info_begin());
-  SubclassOptionalData = CI.SubclassOptionalData;
+  ValueSubclassData().OptionalData = CI.ValueSubclassData().OptionalData;
 }
 
 CallInst *CallInst::Create(CallInst *CI, ArrayRef<OperandBundleDef> OpB,
                            Instruction *InsertPt) {
   std::vector<Value *> Args(CI->arg_begin(), CI->arg_end());
 
   auto *NewCI = CallInst::Create(CI->getFunctionType(), CI->getCalledValue(),
                                  Args, OpB, CI->getName(), InsertPt);
   NewCI->setTailCallKind(CI->getTailCallKind());
   NewCI->setCallingConv(CI->getCallingConv());
-  NewCI->SubclassOptionalData = CI->SubclassOptionalData;
+  NewCI->ValueSubclassData().OptionalData =
+      CI->ValueSubclassData().OptionalData;
   NewCI->setAttributes(CI->getAttributes());
   NewCI->setDebugLoc(CI->getDebugLoc());
   return NewCI;
 }
 
 // Update profile weight for call instruction by scaling it using the ratio
 // of S/T. The meaning of "branch_weights" meta data for call instruction is
 // transfered to represent call count.

 InvokeInst::InvokeInst(const InvokeInst &II)
     : CallBase(II.Attrs, II.FTy, II.getType(), Instruction::Invoke,
                OperandTraits<CallBase>::op_end(this) - II.getNumOperands(),
                II.getNumOperands()) {
   setCallingConv(II.getCallingConv());
   std::copy(II.op_begin(), II.op_end(), op_begin());
   std::copy(II.bundle_op_info_begin(), II.bundle_op_info_end(),
             bundle_op_info_begin());
-  SubclassOptionalData = II.SubclassOptionalData;
 }
 
 InvokeInst *InvokeInst::Create(InvokeInst *II, ArrayRef<OperandBundleDef> OpB,
                                Instruction *InsertPt) {
   std::vector<Value *> Args(II->arg_begin(), II->arg_end());
 
   auto *NewII = InvokeInst::Create(II->getFunctionType(), II->getCalledValue(),
                                    II->getNormalDest(), II->getUnwindDest(),
                                    Args, OpB, II->getName(), InsertPt);
   NewII->setCallingConv(II->getCallingConv());
-  NewII->SubclassOptionalData = II->SubclassOptionalData;
   NewII->setAttributes(II->getAttributes());
   NewII->setDebugLoc(II->getDebugLoc());
   return NewII;
 }
 
 
 LandingPadInst *InvokeInst::getLandingPadInst() const {
   return cast<LandingPadInst>(getUnwindDest()->getFirstNonPHI());

 CallBrInst::CallBrInst(const CallBrInst &CBI)
     : CallBase(CBI.Attrs, CBI.FTy, CBI.getType(), Instruction::CallBr,
                OperandTraits<CallBase>::op_end(this) - CBI.getNumOperands(),
                CBI.getNumOperands()) {
   setCallingConv(CBI.getCallingConv());
   std::copy(CBI.op_begin(), CBI.op_end(), op_begin());
   std::copy(CBI.bundle_op_info_begin(), CBI.bundle_op_info_end(),
             bundle_op_info_begin());
-  SubclassOptionalData = CBI.SubclassOptionalData;
   NumIndirectDests = CBI.NumIndirectDests;
 }
 
 CallBrInst *CallBrInst::Create(CallBrInst *CBI, ArrayRef<OperandBundleDef> OpB,
                                Instruction *InsertPt) {
   std::vector<Value *> Args(CBI->arg_begin(), CBI->arg_end());
 
   auto *NewCBI = CallBrInst::Create(CBI->getFunctionType(),
                                     CBI->getCalledValue(),
                                     CBI->getDefaultDest(),
                                     CBI->getIndirectDests(),
                                     Args, OpB, CBI->getName(), InsertPt);
   NewCBI->setCallingConv(CBI->getCallingConv());
-  NewCBI->SubclassOptionalData = CBI->SubclassOptionalData;
   NewCBI->setAttributes(CBI->getAttributes());
   NewCBI->setDebugLoc(CBI->getDebugLoc());
   NewCBI->NumIndirectDests = CBI->NumIndirectDests;
   return NewCBI;
 }
 
 //===----------------------------------------------------------------------===//
 //                        ReturnInst Implementation
 //===----------------------------------------------------------------------===//
 
 ReturnInst::ReturnInst(const ReturnInst &RI)
     : Instruction(Type::getVoidTy(RI.getContext()), Instruction::Ret,
                   OperandTraits<ReturnInst>::op_end(this) - RI.getNumOperands(),
                   RI.getNumOperands()) {
   if (RI.getNumOperands())
     Op<0>() = RI.Op<0>();
-  SubclassOptionalData = RI.SubclassOptionalData;
 }
 
 ReturnInst::ReturnInst(LLVMContext &C, Value *retVal, Instruction *InsertBefore)
     : Instruction(Type::getVoidTy(C), Instruction::Ret,
                   OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
                   InsertBefore) {
   if (retVal)
     Op<0>() = retVal;

 //                        CleanupReturnInst Implementation
 //===----------------------------------------------------------------------===//
 
 CleanupReturnInst::CleanupReturnInst(const CleanupReturnInst &CRI)
     : Instruction(CRI.getType(), Instruction::CleanupRet,
                   OperandTraits<CleanupReturnInst>::op_end(this) -
                       CRI.getNumOperands(),
                   CRI.getNumOperands()) {
-  setInstructionSubclassData(CRI.getSubclassDataFromInstruction());
-  Op<0>() = CRI.Op<0>();
-  if (CRI.hasUnwindDest())
-    Op<1>() = CRI.Op<1>();
+  init(CRI.getCleanupPad(), CRI.getUnwindDest());
 }
 
 void CleanupReturnInst::init(Value *CleanupPad, BasicBlock *UnwindBB) {
-  if (UnwindBB)
-    setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
-
   Op<0>() = CleanupPad;
-  if (UnwindBB)
+  if (UnwindBB) {
+    ValueSubclassData().HasUnwindDest = true;
     Op<1>() = UnwindBB;
   }
+}
 
 CleanupReturnInst::CleanupReturnInst(Value *CleanupPad, BasicBlock *UnwindBB,
                                      unsigned Values, Instruction *InsertBefore)
     : Instruction(Type::getVoidTy(CleanupPad->getContext()),
                   Instruction::CleanupRet,
                   OperandTraits<CleanupReturnInst>::op_end(this) - Values,
                   Values, InsertBefore) {
   init(CleanupPad, UnwindBB);
void CatchSwitchInst::init(Value *ParentPad, BasicBlock *UnwindDest,
   assert(ParentPad && NumReservedValues);
 
   ReservedSpace = NumReservedValues;
   setNumHungOffUseOperands(UnwindDest ? 2 : 1);
   allocHungoffUses(ReservedSpace);
 
   Op<0>() = ParentPad;
   if (UnwindDest) {
-    setInstructionSubclassData(getSubclassDataFromInstruction() | 1);
+    ValueSubclassData().HasUnwindDest = true;
     setUnwindDest(UnwindDest);
   }
 }
 
 /// growOperands - grow operands - This grows the operand list in response to a
 /// push_back style of operation. This grows the number of ops by 2 times.
 void CatchSwitchInst::growOperands(unsigned Size) {
   unsigned NumOperands = getNumOperands();
: Instruction(Type::getVoidTy(BI.getContext()), Instruction::Br,
                   OperandTraits<BranchInst>::op_end(this) - BI.getNumOperands(),
                   BI.getNumOperands()) {
   Op<-1>() = BI.Op<-1>();
   if (BI.getNumOperands() != 1) {
     assert(BI.getNumOperands() == 3 && "BR can have 1 or 3 operands!");
     Op<-3>() = BI.Op<-3>();
     Op<-2>() = BI.Op<-2>();
   }
-  SubclassOptionalData = BI.SubclassOptionalData;
 }
 
 void BranchInst::swapSuccessors() {
   assert(isConditional() &&
          "Cannot swap successors of an unconditional branch");
   Op<-1>().swap(Op<-2>());
 
   // Update profile metadata if present and it matches our structural
AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
   setAlignment(Align);
   assert(!Ty->isVoidTy() && "Cannot allocate void!");
   setName(Name);
 }
 
 void AllocaInst::setAlignment(MaybeAlign Align) {
   assert((!Align || *Align <= MaximumAlignment) &&
          "Alignment is greater than MaximumAlignment!");
-  setInstructionSubclassData((getSubclassDataFromInstruction() & ~31) |
-                             encode(Align));
+  ValueSubclassData().EncodedAlignment = encode(Align);
   if (Align)
     assert(getAlignment() == Align->value() &&
            "Alignment representation error!");
   else
     assert(getAlignment() == 0 && "Alignment representation error!");
 }
 
 bool AllocaInst::isArrayAllocation() const {
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
   setAtomic(Order, SSID);
   AssertOK();
   setName(Name);
 }
 
 void LoadInst::setAlignment(MaybeAlign Align) {
   assert((!Align || *Align <= MaximumAlignment) &&
          "Alignment is greater than MaximumAlignment!");
-  setInstructionSubclassData((getSubclassDataFromInstruction() & ~(31 << 1)) |
-                             (encode(Align) << 1));
+  ValueSubclassData().EncodedAlignment = encode(Align);
   assert(getAlign() == Align && "Alignment representation error!");
 }
 
 //===----------------------------------------------------------------------===//
 //                           StoreInst Implementation
 //===----------------------------------------------------------------------===//
 
 void StoreInst::AssertOK() {
StoreInst::StoreInst(Value *val, Value *addr, bool isVolatile, MaybeAlign Align,
   setAlignment(Align);
   setAtomic(Order, SSID);
   AssertOK();
 }
 
 void StoreInst::setAlignment(MaybeAlign Alignment) {
   assert((!Alignment || *Alignment <= MaximumAlignment) &&
          "Alignment is greater than MaximumAlignment!");
-  setInstructionSubclassData((getSubclassDataFromInstruction() & ~(31 << 1)) |
-                             (encode(Alignment) << 1));
+  ValueSubclassData().EncodedAlignment = encode(Alignment);
   assert(getAlign() == Alignment && "Alignment representation error!");
 }
 
 //===----------------------------------------------------------------------===//
 //                       AtomicCmpXchgInst Implementation
 //===----------------------------------------------------------------------===//
 
 void AtomicCmpXchgInst::Init(Value *Ptr, Value *Cmp, Value *NewVal,

 GetElementPtrInst::GetElementPtrInst(const GetElementPtrInst &GEPI)
     : Instruction(GEPI.getType(), GetElementPtr,
                   OperandTraits<GetElementPtrInst>::op_end(this) -
                       GEPI.getNumOperands(),
                   GEPI.getNumOperands()),
       SourceElementType(GEPI.SourceElementType),
       ResultElementType(GEPI.ResultElementType) {
   std::copy(GEPI.op_begin(), GEPI.op_end(), op_begin());
-  SubclassOptionalData = GEPI.SubclassOptionalData;
+  ValueSubclassData().OptionalData = GEPI.ValueSubclassData().OptionalData;
 }
 
 /// getIndexedType - Returns the type of the element that would be accessed with
 /// a gep instruction with the specified parameters.
 ///
 /// The Idxs pointer should point to a continuous piece of memory containing the
 /// indices, either as Value* or uint64_t.
 ///

 }
 
 InsertValueInst::InsertValueInst(const InsertValueInst &IVI)
   : Instruction(IVI.getType(), InsertValue,
                 OperandTraits<InsertValueInst>::op_begin(this), 2),
     Indices(IVI.Indices) {
   Op<0>() = IVI.getOperand(0);
   Op<1>() = IVI.getOperand(1);
-  SubclassOptionalData = IVI.SubclassOptionalData;
 }
 
 //===----------------------------------------------------------------------===//
 //                             ExtractValueInst Class
 //===----------------------------------------------------------------------===//
 
 void ExtractValueInst::init(ArrayRef<unsigned> Idxs, const Twine &Name) {
   assert(getNumOperands() == 1 && "NumOperands not initialized?");
 
   // There's no fundamental reason why we require at least one index.
   // But there's no present need to support it.
   assert(!Idxs.empty() && "ExtractValueInst must have at least one index");
 
   Indices.append(Idxs.begin(), Idxs.end());
   setName(Name);
 }
 
 ExtractValueInst::ExtractValueInst(const ExtractValueInst &EVI)
   : UnaryInstruction(EVI.getType(), ExtractValue, EVI.getOperand(0)),
-    Indices(EVI.Indices) {
-  SubclassOptionalData = EVI.SubclassOptionalData;
-}
+    Indices(EVI.Indices) {}
 
 // getIndexedType - Returns the type of the element that would be extracted
 // with an extractvalue instruction with the specified parameters.
 //
 // A null type is returned if the indices are invalid for the specified
 // pointer type.
 //
 Type *ExtractValueInst::getIndexedType(Type *Agg,
SwitchInst::SwitchInst(const SwitchInst &SI)
   init(SI.getCondition(), SI.getDefaultDest(), SI.getNumOperands());
   setNumHungOffUseOperands(SI.getNumOperands());
   Use *OL = getOperandList();
   const Use *InOL = SI.getOperandList();
   for (unsigned i = 2, E = SI.getNumOperands(); i != E; i += 2) {
     OL[i] = InOL[i];
     OL[i+1] = InOL[i+1];
   }
-  SubclassOptionalData = SI.SubclassOptionalData;
 }
 
 /// addCase - Add an entry to the switch instruction...
 ///
 void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) {
   unsigned NewCaseIdx = getNumCases();
   unsigned OpNo = getNumOperands();
   if (OpNo+2 > ReservedSpace)

 IndirectBrInst::IndirectBrInst(const IndirectBrInst &IBI)
     : Instruction(Type::getVoidTy(IBI.getContext()), Instruction::IndirectBr,
                   nullptr, IBI.getNumOperands()) {
   allocHungoffUses(IBI.getNumOperands());
   Use *OL = getOperandList();
   const Use *InOL = IBI.getOperandList();
   for (unsigned i = 0, E = IBI.getNumOperands(); i != E; ++i)
     OL[i] = InOL[i];
-  SubclassOptionalData = IBI.SubclassOptionalData;
 }
 
 /// addDestination - Add a destination.
 ///
 void IndirectBrInst::addDestination(BasicBlock *DestBB) {
   unsigned OpNo = getNumOperands();
   if (OpNo+1 > ReservedSpace)
     growOperands();  // Get more space!

llvm/lib/IR/Type.cpp

 //                       FunctionType Implementation
 //===----------------------------------------------------------------------===//
 
 FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
                            bool IsVarArgs)
   : Type(Result->getContext(), FunctionTyID) {
   Type **SubTys = reinterpret_cast<Type**>(this+1);
   assert(isValidReturnType(Result) && "invalid return type for function");
-  setSubclassData(IsVarArgs);
+  TypeSubclassData().IsVarArgs = IsVarArgs;
 
   SubTys[0] = Result;
 
   for (unsigned i = 0, e = Params.size(); i != e; ++i) {
     assert(isValidArgumentType(Params[i]) &&
            "Not a valid type for function argument!");
     SubTys[i+1] = Params[i];
   }
StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes,
   // one for inserting the newly allocated one), here we instead lookup based on
   // Key and update the reference to the struct type in-place to a newly
   // allocated one if not found.
   auto Insertion = pImpl->AnonStructTypes.insert_as(nullptr, Key);
   if (Insertion.second) {
     // The struct type was not found. Allocate one and update AnonStructTypes
     // in-place.
     ST = new (Context.pImpl->Alloc) StructType(Context);
-    ST->setSubclassData(SCDB_IsLiteral);  // Literal struct.
+    ST->TypeSubclassData().IsLiteral = true;  // Literal struct.
     ST->setBody(ETypes, isPacked);
     *Insertion.first = ST;
   } else {
     // The struct type was found. Just return it.
     ST = *Insertion.first;
   }
 
   return ST;
 }
 
 void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) {
   assert(isOpaque() && "Struct body already set!");
 
-  setSubclassData(getSubclassData() | SCDB_HasBody);
-  if (isPacked)
-    setSubclassData(getSubclassData() | SCDB_Packed);
+  TypeSubclassData().HasBody = true;
+  TypeSubclassData().Packed = isPacked;
 
   NumContainedTys = Elements.size();
 
   if (Elements.empty()) {
     ContainedTys = nullptr;
     return;
   }
 

 
 StructType *StructType::create(ArrayRef<Type*> Elements) {
   assert(!Elements.empty() &&
          "This method may not be invoked with an empty list");
   return create(Elements[0]->getContext(), Elements, StringRef());
 }
 
 bool StructType::isSized(SmallPtrSetImpl<Type*> *Visited) const {
-  if ((getSubclassData() & SCDB_IsSized) != 0)
+  if (TypeSubclassData().IsSized)
     return true;
   if (isOpaque())
     return false;
 
   if (Visited && !Visited->insert(const_cast<StructType*>(this)).second)
     return false;
 
   // Okay, our struct is sized if all of the elements are, but if one of the
   // elements is opaque, the struct isn't sized *yet*, but may become sized in
   // the future, so just bail out without caching.
   for (element_iterator I = element_begin(), E = element_end(); I != E; ++I)
     if (!(*I)->isSized(Visited))
       return false;
 
   // Here we cheat a bit and cast away const-ness. The goal is to memoize when
   // we find a sized type, as types can only move from opaque to sized, not the
   // other way.
-  const_cast<StructType*>(this)->setSubclassData(
-    getSubclassData() | SCDB_IsSized);
+  const_cast<StructType*>(this)->TypeSubclassData().IsSized = true;
   return true;
 }
 
 StringRef StructType::getName() const {
   assert(!isLiteral() && "Literal structs never have names");
   if (!SymbolTableEntry) return StringRef();
 
   return ((StringMapEntry<StructType*> *)SymbolTableEntry)->getKey();
if (!Entry)
     Entry = new (CImpl->Alloc) PointerType(EltTy, AddressSpace);
   return Entry;
 }
 
 PointerType::PointerType(Type *E, unsigned AddrSpace)
   : Type(E->getContext(), PointerTyID), PointeeTy(E) {
   ContainedTys = &PointeeTy;
   NumContainedTys = 1;
-  setSubclassData(AddrSpace);
+  TypeSubclassData().AddressSpace = AddrSpace;
 }
 
 PointerType *Type::getPointerTo(unsigned addrs) const {
   return PointerType::get(const_cast<Type*>(this), addrs);
 }
 
 bool PointerType::isValidElementType(Type *ElemTy) {
   return !ElemTy->isVoidTy() && !ElemTy->isLabelTy() &&
          !ElemTy->isMetadataTy() && !ElemTy->isTokenTy();
 }
 
 bool PointerType::isLoadableOrStorableType(Type *ElemTy) {
   return isValidElementType(ElemTy) && !ElemTy->isFunctionTy();
 }

llvm/lib/IR/User.cpp

 
 namespace llvm {
 class BasicBlock;
 
 //===----------------------------------------------------------------------===//
 //                                 User Class
 //===----------------------------------------------------------------------===//
 
+User::User(Type *ty, unsigned vty, Use *, unsigned NumOps)
+    : Value(ty, vty,
+            (bit_maskof(ValueSubclassData().HasDescriptor) |
+             bit_maskof(ValueSubclassData().HasHungOffUses) |
+             bit_maskof(ValueSubclassData().NumOperands))) {
+  setNumOperands(NumOps);
+
+  // If we have hung off uses, then the operand list should initially be
+  // null.
+  assert((!hasHungOffUses() || !getOperandList()) &&
+         "Error in initializing hung off uses for User");
+}
+
 void User::replaceUsesOfWith(Value *From, Value *To) {
   if (From == To) return;   // Duh what?
 
   assert((!isa<Constant>(this) || isa<GlobalValue>(this)) &&
          "Cannot call User::replaceUsesOfWith on a constant!");
 
   for (unsigned i = 0, E = getNumOperands(); i != E; ++i)
     if (getOperand(i) == From) {  // Is This operand is pointing to oldval?
       // The side effects of this setOperand call include linking to
       // "To", adding "this" to the uses list of To, and
       // most importantly, removing "this" from the use list of "From".
       setOperand(i, To); // Fix it now...
     }
 }
 
 //===----------------------------------------------------------------------===//
 //                         User allocHungoffUses Implementation
 //===----------------------------------------------------------------------===//
 
 void User::allocHungoffUses(unsigned N, bool IsPhi) {
-  assert(HasHungOffUses && "alloc must have hung off uses");
+  assert(hasHungOffUses() && "alloc must have hung off uses");
 
   static_assert(alignof(Use) >= alignof(Use::UserRef),
                 "Alignment is insufficient for 'hung-off-uses' pieces");
   static_assert(alignof(Use::UserRef) >= alignof(BasicBlock *),
                 "Alignment is insufficient for 'hung-off-uses' pieces");
 
   // Allocate the array of Uses, followed by a pointer (with bottom bit set) to
   // the User.
   size_t size = N * sizeof(Use) + sizeof(Use::UserRef);
   if (IsPhi)
     size += N * sizeof(BasicBlock *);
   Use *Begin = static_cast<Use*>(::operator new(size));
   Use *End = Begin + N;
   (void) new(End) Use::UserRef(const_cast<User*>(this), 1);
   setOperandList(Use::initTags(Begin, End));
 }
 
 void User::growHungoffUses(unsigned NewNumUses, bool IsPhi) {
-  assert(HasHungOffUses && "realloc must have hung off uses");
+  assert(hasHungOffUses() && "realloc must have hung off uses");
 
   unsigned OldNumUses = getNumOperands();
 
   // We don't support shrinking the number of uses.  We wouldn't have enough
   // space to copy the old uses in to the new space.
   assert(NewNumUses > OldNumUses && "realloc must grow num uses");
 
   Use *OldOps = getOperandList();

 };
 
 ArrayRef<const uint8_t> User::getDescriptor() const {
   auto MutableARef = const_cast<User *>(this)->getDescriptor();
   return {MutableARef.begin(), MutableARef.end()};
 }
 
 MutableArrayRef<uint8_t> User::getDescriptor() {
-  assert(HasDescriptor && "Don't call otherwise!");
-  assert(!HasHungOffUses && "Invariant!");
+  assert(ValueSubclassData().HasDescriptor && "Don't call otherwise!");
+  assert(!hasHungOffUses() && "Invariant!");
 
   auto *DI = reinterpret_cast<DescriptorInfo *>(getIntrusiveOperands()) - 1;
   assert(DI->SizeInBytes != 0 && "Should not have had a descriptor otherwise!");
 
   return MutableArrayRef<uint8_t>(
       reinterpret_cast<uint8_t *>(DI) - DI->SizeInBytes, DI->SizeInBytes);
 }
 
 //===----------------------------------------------------------------------===//
 //                         User operator new Implementations
 //===----------------------------------------------------------------------===//
 
 void *User::allocateFixedOperandUser(size_t Size, unsigned Us,
                                      unsigned DescBytes) {
-  assert(Us < (1u << NumUserOperandsBits) && "Too many operands");
-
   static_assert(sizeof(DescriptorInfo) % sizeof(void *) == 0, "Required below");
 
   unsigned DescBytesToAllocate =
       DescBytes == 0 ? 0 : (DescBytes + sizeof(DescriptorInfo));
   assert(DescBytesToAllocate % sizeof(void *) == 0 &&
          "We need this to satisfy alignment constraints for Uses");
 
   uint8_t *Storage = static_cast<uint8_t *>(
       ::operator new(Size + sizeof(Use) * Us + DescBytesToAllocate));
   Use *Start = reinterpret_cast<Use *>(Storage + DescBytesToAllocate);
   Use *End = Start + Us;
   User *Obj = reinterpret_cast<User*>(End);
-  Obj->NumUserOperands = Us;
-  Obj->HasHungOffUses = false;
-  Obj->HasDescriptor = DescBytes != 0;
+  Obj->setNumOperands(Us);
+  Obj->ValueSubclassData().HasHungOffUses = false;
+  Obj->ValueSubclassData().HasDescriptor = DescBytes != 0;
   Use::initTags(Start, End);
 
   if (DescBytes != 0) {
     auto *DescInfo = reinterpret_cast<DescriptorInfo *>(Storage + DescBytes);
     DescInfo->SizeInBytes = DescBytes;
   }
 
   return Obj;
 }
 
 void *User::operator new(size_t Size, unsigned Us) {
   return allocateFixedOperandUser(Size, Us, 0);
 }
 
 void *User::operator new(size_t Size, unsigned Us, unsigned DescBytes) {
   return allocateFixedOperandUser(Size, Us, DescBytes);
 }
 
 void *User::operator new(size_t Size) {
   // Allocate space for a single Use*
   void *Storage = ::operator new(Size + sizeof(Use *));
   Use **HungOffOperandList = static_cast<Use **>(Storage);
   User *Obj = reinterpret_cast<User *>(HungOffOperandList + 1);
-  Obj->NumUserOperands = 0;
-  Obj->HasHungOffUses = true;
-  Obj->HasDescriptor = false;
+  Obj->setNumOperands(0);
+  Obj->ValueSubclassData().HasHungOffUses = true;
+  Obj->ValueSubclassData().HasDescriptor = false;
   *HungOffOperandList = nullptr;
   return Obj;
 }
 
 //===----------------------------------------------------------------------===//
 //                         User operator delete Implementation
 //===----------------------------------------------------------------------===//
 
 // Repress memory sanitization, due to use-after-destroy by operator
 // delete. Bug report 24578 identifies this issue.
 LLVM_NO_SANITIZE_MEMORY_ATTRIBUTE void User::operator delete(void *Usr) {
   // Hung off uses use a single Use* before the User, while other subclasses
   // use a Use[] allocated prior to the user.
   User *Obj = static_cast<User *>(Usr);
-  if (Obj->HasHungOffUses) {
-    assert(!Obj->HasDescriptor && "not supported!");
+  if (Obj->hasHungOffUses()) {
+    assert(!Obj->ValueSubclassData().HasDescriptor && "not supported!");
 
     Use **HungOffOperandList = static_cast<Use **>(Usr) - 1;
     // drop the hung off uses.
-    Use::zap(*HungOffOperandList, *HungOffOperandList + Obj->NumUserOperands,
+    Use::zap(*HungOffOperandList, *HungOffOperandList + Obj->getNumOperands(),
              /* Delete */ true);
     ::operator delete(HungOffOperandList);
-  } else if (Obj->HasDescriptor) {
-    Use *UseBegin = static_cast<Use *>(Usr) - Obj->NumUserOperands;
-    Use::zap(UseBegin, UseBegin + Obj->NumUserOperands, /* Delete */ false);
+  } else if (Obj->ValueSubclassData().HasDescriptor) {
+    Use *UseBegin = static_cast<Use *>(Usr) - Obj->getNumOperands();
+    Use::zap(UseBegin, UseBegin + Obj->getNumOperands(), /* Delete */ false);
 
     auto *DI = reinterpret_cast<DescriptorInfo *>(UseBegin) - 1;
     uint8_t *Storage = reinterpret_cast<uint8_t *>(DI) - DI->SizeInBytes;
     ::operator delete(Storage);
   } else {
-    Use *Storage = static_cast<Use *>(Usr) - Obj->NumUserOperands;
-    Use::zap(Storage, Storage + Obj->NumUserOperands,
+    Use *Storage = static_cast<Use *>(Usr) - Obj->getNumOperands();
+    Use::zap(Storage, Storage + Obj->getNumOperands(),
              /* Delete */ false);
     ::operator delete(Storage);
   }
 }
 
 } // End llvm namespace

llvm/lib/IR/Value.cpp

 //===----------------------------------------------------------------------===//
 //                                Value Class
 //===----------------------------------------------------------------------===//
 static inline Type *checkType(Type *Ty) {
   assert(Ty && "Value defined with a null type: Error!");
   return Ty;
 }
 
-Value::Value(Type *ty, unsigned scid)
-    : VTy(checkType(ty)), UseList(nullptr), SubclassID(scid),
-      HasValueHandle(0), SubclassOptionalData(0), SubclassData(0),
-      NumUserOperands(0), IsUsedByMD(false), HasName(false) {
+Value::Value(Type *ty, unsigned scid, uint64_t PreservedSubclassDataMask)
+    : VTy(checkType(ty)), UseList(nullptr),
+      PackedBitfieldsData(PackedBitfieldsData & bit_maskof(SubclassData) &
+                          PreservedSubclassDataMask) {
+  SubclassID = scid;
+
   static_assert(ConstantFirstVal == 0, "!(SubclassID < ConstantFirstVal)");
   // FIXME: Why isn't this in the subclass gunk??
   // Note, we cannot call isa<CallInst> before the CallInst has been
   // constructed.
   if (SubclassID == Instruction::Call || SubclassID == Instruction::Invoke ||
       SubclassID == Instruction::CallBr)
     assert((VTy->isFirstClassType() || VTy->isVoidTy() || VTy->isStructTy()) &&
            "invalid CallInst type!");
assert(I != Ctx.pImpl->ValueNames.end() &&
          "No name entry found!");
 
   return I->second;
 }
 
 void Value::setValueName(ValueName *VN) {
   LLVMContext &Ctx = getContext();
 
-  assert(HasName == Ctx.pImpl->ValueNames.count(this) &&
+  assert(HasName == !!Ctx.pImpl->ValueNames.count(this) &&
          "HasName bit out of sync!");
 
   if (!VN) {
     if (HasName)
       Ctx.pImpl->ValueNames.erase(this);
     HasName = false;
     return;
   }

llvm/lib/Transforms/InstCombine/InstructionCombining.cpp

static bool hasNoUnsignedWrap(BinaryOperator &I) {
   return OBO && OBO->hasNoUnsignedWrap();
 }
 
 static bool hasNoSignedWrap(BinaryOperator &I) {
   auto *OBO = dyn_cast<OverflowingBinaryOperator>(&I);
   return OBO && OBO->hasNoSignedWrap();
 }
 
-/// Conservatively clears subclassOptionalData after a reassociation or
-/// commutation. We preserve fast-math flags when applicable as they can be
-/// preserved.
+/// Conservatively clears OptionalData after a reassociation or commutation.
+/// We preserve fast-math flags when applicable as they can be preserved.
 static void ClearSubclassDataAfterReassociation(BinaryOperator &I) {
-  FPMathOperator *FPMO = dyn_cast<FPMathOperator>(&I);
-  if (!FPMO) {
-    I.clearSubclassOptionalData();
-    return;
+  if (isa<PossiblyExactOperator>(I))
+    I.setIsExact(false);
+  else if (isa<OverflowingBinaryOperator>(I)) {
+    I.setHasNoUnsignedWrap(false);
+    I.setHasNoSignedWrap(false);
   }
-
-  FastMathFlags FMF = I.getFastMathFlags();
-  I.clearSubclassOptionalData();
-  I.setFastMathFlags(FMF);
 }
 
 /// Combine constant operands of associative operations either before or after a
 /// cast to eliminate one of the associative operations:
 /// (op (cast (op X, C2)), C1) --> (cast (op X, op (C1, C2)))
 /// (op (cast (op X, C2)), C1) --> (op (cast X), op (C1, C2))
 static bool simplifyAssocCastAssoc(BinaryOperator *BinOp1) {
   auto *Cast = dyn_cast<CastInst>(BinOp1->getOperand(0));

llvm/lib/Transforms/Scalar/Reassociate.cpp

void ReassociatePass::RewriteExprTree(BinaryOperator *I,
   }
 
   // If the expression changed non-trivially then clear out all subclass data
   // starting from the operator specified in ExpressionChanged, and compactify
   // the operators to just before the expression root to guarantee that the
   // expression tree is dominated by all of Ops.
   if (ExpressionChanged)
     do {
-      // Preserve FastMathFlags.
-      if (isa<FPMathOperator>(I)) {
-        FastMathFlags Flags = I->getFastMathFlags();
-        ExpressionChanged->clearSubclassOptionalData();
-        ExpressionChanged->setFastMathFlags(Flags);
-      } else
-        ExpressionChanged->clearSubclassOptionalData();
+      // Preserve FastMathFlags, clear others.
+      if (isa<FPMathOperator>(I))
+        ExpressionChanged->copyFastMathFlags(I);
+      else if (isa<PossiblyExactOperator>(I))
+        ExpressionChanged->setIsExact(false);
+      else if (isa<OverflowingBinaryOperator>(I)) {
+        ExpressionChanged->setHasNoUnsignedWrap(false);
+        ExpressionChanged->setHasNoSignedWrap(false);
+      }
 
       if (ExpressionChanged == I)
         break;
 
       // Discard any debug info related to the expressions that has changed (we
       // can leave debug infor related to the root, since the result of the
       // expression tree should be the same even after reassociation).
       replaceDbgUsesWithUndef(ExpressionChanged);

llvm/lib/Transforms/Utils/FunctionComparator.cpp

 }
 
 int FunctionComparator::cmpOrderings(AtomicOrdering L, AtomicOrdering R) const {
   if ((int)L < (int)R) return -1;
   if ((int)L > (int)R) return 1;
   return 0;
 }
 
+int FunctionComparator::cmpFastMathFlags(FastMathFlags L,
+                                         FastMathFlags R) const {
+  if (L < R) return -1;
+  if (L > R) return 1;
+  return 0;
+}
+
 int FunctionComparator::cmpAPInts(const APInt &L, const APInt &R) const {
   if (int Res = cmpNumbers(L.getBitWidth(), R.getBitWidth()))
     return Res;
   if (L.ugt(R)) return 1;
   if (R.ugt(L)) return -1;
   return 0;
 }
 
int FunctionComparator::cmpOperations(const Instruction *L,
                                       const Instruction *R,
                                       bool &needToCmpOperands) const {
   needToCmpOperands = true;
   if (int Res = cmpValues(L, R))
     return Res;
 
   // Differences from Instruction::isSameOperationAs:
   //  * replace type comparison with calls to cmpTypes.
-  //  * we test for I->getRawSubclassOptionalData (nuw/nsw/tail) at the top.
+  //  * we test for OptionalData (nuw/nsw/tail) at the top.
   //  * because of the above, we don't test for the tail bit on calls later on.
   if (int Res = cmpNumbers(L->getOpcode(), R->getOpcode()))
     return Res;
 
   if (const GetElementPtrInst *GEPL = dyn_cast<GetElementPtrInst>(L)) {
     needToCmpOperands = false;
     const GetElementPtrInst *GEPR = cast<GetElementPtrInst>(R);
     if (int Res =
             cmpValues(GEPL->getPointerOperand(), GEPR->getPointerOperand()))
       return Res;
     return cmpGEPs(GEPL, GEPR);
   }
 
   if (int Res = cmpNumbers(L->getNumOperands(), R->getNumOperands()))
     return Res;
 
   if (int Res = cmpTypes(L->getType(), R->getType()))
     return Res;
 
-  if (int Res = cmpNumbers(L->getRawSubclassOptionalData(),
-                           R->getRawSubclassOptionalData()))
+  // Compare OptionalData.
+  if (isa<OverflowingBinaryOperator>(L)) {
+    if (int Res = cmpNumbers(L->hasNoUnsignedWrap(), R->hasNoUnsignedWrap()))
       return Res;
+    if (int Res = cmpNumbers(L->hasNoSignedWrap(), R->hasNoSignedWrap()))
+      return Res;
+  } else if (isa<PossiblyExactOperator>(L)) {
+    if (int Res = cmpNumbers(L->isExact(), R->isExact()))
+      return Res;
+  } else if (isa<FPMathOperator>(L)) {
+    if (int Res =
+            cmpFastMathFlags(L->getFastMathFlags(), R->getFastMathFlags()))
+      return Res;
+  }
 
   // We have two instructions of identical opcode and #operands.  Check to see
   // if all operands are the same type
   for (unsigned i = 0, e = L->getNumOperands(); i != e; ++i) {
     if (int Res =
             cmpTypes(L->getOperand(i)->getType(), R->getOperand(i)->getType()))
       return Res;
   }