[ptr-traits] Add a LowPointerIntPair alias

[njames93]

Summary

This adds an LowPointerIntPair alias that makes a PointerIntPair store the int in the lowest bit positions.
This partially limits chaining, but simplifies accessing the int by removing the need for shifts.

[njames93]

Fix compilation error in assert enabled build

llvm/include/llvm/ADT/PointerIntPair.h

Value = Info::updateInt(Info::updatePointer(0, PtrVal),
                             static_cast<intptr_t>(IntVal));
   }
 
   PointerTy const *getAddrOfPointer() const {
     return const_cast<PointerIntPair *>(this)->getAddrOfPointer();
   }
 
   PointerTy *getAddrOfPointer() {
     assert(Value == reinterpret_cast<intptr_t>(getPointer()) &&
            "Can only return the address if IntBits is cleared and "
            "PtrTraits doesn't change the pointer");
     return reinterpret_cast<PointerTy *>(&Value);
   }
 
   void *getOpaqueValue() const { return reinterpret_cast<void *>(Value); }
 
   void setFromOpaqueValue(void *Val) LLVM_LVALUE_FUNCTION {
bool operator<=(const PointerIntPair &RHS) const {
     return Value <= RHS.Value;
   }
 
   bool operator>=(const PointerIntPair &RHS) const {
     return Value >= RHS.Value;
   }
 };
 
+namespace detail {
+template <typename T, unsigned Bits> struct ForceLowBitsPointerTraits {
+  using Base = llvm::PointerLikeTypeTraits<T>;
+  static_assert(Bits <= Base::NumLowBitsAvailable,
+                "Too many bits specified for Base Traits");
+
+  static inline void *getAsVoidPointer(T P) {
+    return Base::getAsVoidPointer(P);
+  }
+  static inline T getFromVoidPointer(void *P) {
+    return Base::getFromVoidPointer(P);
+  }
+
+  static constexpr int NumLowBitsAvailable = Bits;
+};
+} // namespace detail
+
+/// LowPointerIntPair - This is a \ref PointerIntPair that stores the IntVal in
+/// the lowest bits. This removes the need for shifts when accessing the stored
+/// IntVal. As it is using the lowest bits, this can't be used as a PointerType
+/// inside a nested PointerIntPair. However it can have nested PointerIntPairs
+/// used as its own PointerType, like this:
+///   LowPointerIntPair<PointerIntPair<void*, 1>, 1>
+/// LowPointerIntPair will use bit #0,
+/// PointerIntPair will use bit #1 or #2 depending on alignment of void*.
+template <typename PointerTy, unsigned IntBits, typename IntType = unsigned>
+using LowPointerIntPair =
+    PointerIntPair<PointerTy, IntBits, IntType,
+                   detail::ForceLowBitsPointerTraits<PointerTy, IntBits>>;
+
 // Specialize is_trivially_copyable to avoid limitation of llvm::is_trivially_copyable
 // when compiled with gcc 4.9.
 template <typename PointerTy, unsigned IntBits, typename IntType,
           typename PtrTraits,
           typename Info>
 struct is_trivially_copyable<PointerIntPair<PointerTy, IntBits, IntType, PtrTraits, Info>> : std::true_type {
 #ifdef HAVE_STD_IS_TRIVIALLY_COPYABLE
   static_assert(std::is_trivially_copyable<PointerIntPair<PointerTy, IntBits, IntType, PtrTraits, Info>>::value,

llvm/unittests/ADT/PointerIntPairTest.cpp

EXPECT_EQ(FixnumPointerTraits::NumLowBitsAvailable - 1,
             (int)PointerLikeTypeTraits<decltype(pair)>::NumLowBitsAvailable);
 
   static_assert(
       is_trivially_copyable<
           PointerIntPair<Fixnum31, 1, bool, FixnumPointerTraits>>::value,
       "trivially copyable");
 }
 
+TEST(PointerIntPairTest, LowPointerIntPair) {
+  static_assert(PointerLikeTypeTraits<
+                    LowPointerIntPair<void *, 1>>::NumLowBitsAvailable == 0,
+                "Using LowestBits");
+
+  // Use double as guaranteed 8 byte alignment on 32 or 64 bit, meaning 3 bits
+  // to play with.
+  LowPointerIntPair<PointerIntPair<double *, 1, bool>, 1, bool> P;
+  // Ensure they are both using different bits, and that the LowPointerIntPair
+  // is using the LSB.
+  P.setPointerAndInt({nullptr, true}, false);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P.getOpaqueValue()), 0b100U);
+  P.setInt(true);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P.getOpaqueValue()), 0b101U);
+  P.getAddrOfPointer()->setInt(false);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(P.getOpaqueValue()), 0b001U);
+}
+
 } // end anonymous namespace