[ADT] Fix support for over-aligned pointers in PointerSumType

[eush]

Summary

This fixes compilation error when the tag of PointerSumType is wider than an
int, which is the case when the payload has too many low bits available.

E.g. on x86-64 when the payload is 8 bit wide and the tag is 56 bit wide, GCC
reports the following error message:

include/llvm/ADT/PointerSumType.h:252:37: error: right operand of shift expression ‘(1 << 56)’ is >= than the precision of the left operand [-fpermissive]
     static_assert(MemberT::Tag < (1 << NumTagBits),
                                  ~~~^~~~~~~~~~~~~~

[eush]

Removed FIXME.

[eush]

unittests/ADT/PointerSumTypeTest.cpp

36

This is formatted by clang-format and the indentation is a bit weird. A using declaration would be indented more nicely, but I sticked to typedef for consistency.

include/llvm/ADT/PointerSumType.h

enum : uint64_t {
     PointerMask = static_cast<uint64_t>(-1) << NumTagBits,
     TagMask = ~PointerMask
   };
 
   // Finally we need a recursive template to do static checks of each
   // member.
   template <typename MemberT, typename... InnerMemberTs>
   struct Checker : Checker<InnerMemberTs...> {
-    static_assert(MemberT::Tag < (1 << NumTagBits),
+    static_assert(MemberT::Tag < (UINTMAX_C(1) << NumTagBits),
                   "This discriminant value requires too many bits!");
   };
   template <typename MemberT> struct Checker<MemberT> : std::true_type {
-    static_assert(MemberT::Tag < (1 << NumTagBits),
+    static_assert(MemberT::Tag < (UINTMAX_C(1) << NumTagBits),
                   "This discriminant value requires too many bits!");
   };
   static_assert(Checker<MemberTs...>::value,
                 "Each member must pass the checker.");
 };
 
 } // end namespace detail
 

unittests/ADT/PointerSumTypeTest.cpp

 //===- llvm/unittest/ADT/PointerSumTypeTest.cpp ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/PointerEmbeddedInt.h"
 #include "llvm/ADT/PointerSumType.h"
 #include "gtest/gtest.h"
 using namespace llvm;
 
 namespace {
 
 struct PointerSumTypeTest : public testing::Test {
   enum Kinds { Float, Int1, Int2 };
   float f;
   int i1, i2;
 
+  enum NarrowKinds { EmbeddedInt1, EmbeddedChar };
+  unsigned ei1;
+  char ec;
+
   typedef PointerSumType<Kinds, PointerSumTypeMember<Float, float *>,
                          PointerSumTypeMember<Int1, int *>,
                          PointerSumTypeMember<Int2, int *>>
       SumType;
   SumType a, b, c, n;
 
+  typedef PointerSumType<
+      NarrowKinds,
+      PointerSumTypeMember<EmbeddedInt1, PointerEmbeddedInt<unsigned, 1>>,
+      PointerSumTypeMember<EmbeddedChar, PointerEmbeddedInt<char>>>
+      NarrowSumType;
+  NarrowSumType d, e;
+
   PointerSumTypeTest()
-      : f(3.14f), i1(42), i2(-1), a(SumType::create<Float>(&f)),
-        b(SumType::create<Int1>(&i1)), c(SumType::create<Int2>(&i2)), n() {}
+      : f(3.14f), i1(42), i2(-1), ei1(1), ec('c'),
+        a(SumType::create<Float>(&f)), b(SumType::create<Int1>(&i1)),
+        c(SumType::create<Int2>(&i2)), n(),
+        d(NarrowSumType::create<EmbeddedInt1>(ei1)),
+        e(NarrowSumType::create<EmbeddedChar>(ec)) {}
 };
 
 TEST_F(PointerSumTypeTest, NullTest) {
   EXPECT_TRUE(a);
   EXPECT_TRUE(b);
   EXPECT_TRUE(c);
   EXPECT_FALSE(n);
+  EXPECT_TRUE(d);
+  EXPECT_TRUE(e);
 }
 
 TEST_F(PointerSumTypeTest, GetTag) {
   EXPECT_EQ(Float, a.getTag());
   EXPECT_EQ(Int1, b.getTag());
   EXPECT_EQ(Int2, c.getTag());
   EXPECT_EQ((Kinds)0, n.getTag());
+  EXPECT_EQ(EmbeddedInt1, d.getTag());
+  EXPECT_EQ(EmbeddedChar, e.getTag());
 }
 
 TEST_F(PointerSumTypeTest, Is) {
   EXPECT_TRUE(a.is<Float>());
   EXPECT_FALSE(a.is<Int1>());
   EXPECT_FALSE(a.is<Int2>());
   EXPECT_FALSE(b.is<Float>());
   EXPECT_TRUE(b.is<Int1>());
   EXPECT_FALSE(b.is<Int2>());
   EXPECT_FALSE(c.is<Float>());
   EXPECT_FALSE(c.is<Int1>());
   EXPECT_TRUE(c.is<Int2>());
+  EXPECT_TRUE(d.is<EmbeddedInt1>());
+  EXPECT_FALSE(d.is<EmbeddedChar>());
+  EXPECT_FALSE(e.is<EmbeddedInt1>());
+  EXPECT_TRUE(e.is<EmbeddedChar>());
 }
 
 TEST_F(PointerSumTypeTest, Get) {
   EXPECT_EQ(&f, a.get<Float>());
   EXPECT_EQ(nullptr, a.get<Int1>());
   EXPECT_EQ(nullptr, a.get<Int2>());
   EXPECT_EQ(nullptr, b.get<Float>());
   EXPECT_EQ(&i1, b.get<Int1>());
   EXPECT_EQ(nullptr, b.get<Int2>());
   EXPECT_EQ(nullptr, c.get<Float>());
   EXPECT_EQ(nullptr, c.get<Int1>());
   EXPECT_EQ(&i2, c.get<Int2>());
 
   // Note that we can use .get even on a null sum type. It just always produces
   // a null pointer, even if one of the discriminants is null.
   EXPECT_EQ(nullptr, n.get<Float>());
   EXPECT_EQ(nullptr, n.get<Int1>());
   EXPECT_EQ(nullptr, n.get<Int2>());
+
+  EXPECT_EQ(ei1, d.get<EmbeddedInt1>());
+  EXPECT_EQ('\0', d.get<EmbeddedChar>());
+  EXPECT_EQ(0U, e.get<EmbeddedInt1>());
+  EXPECT_EQ(ec, e.get<EmbeddedChar>());
 }
 
 TEST_F(PointerSumTypeTest, Cast) {
   EXPECT_EQ(&f, a.cast<Float>());
   EXPECT_EQ(&i1, b.cast<Int1>());
   EXPECT_EQ(&i2, c.cast<Int2>());
+  EXPECT_EQ(ei1, d.cast<EmbeddedInt1>());
+  EXPECT_EQ(ec, e.cast<EmbeddedChar>());
 }
 
 TEST_F(PointerSumTypeTest, Assignment) {
   b = SumType::create<Int2>(&i2);
   EXPECT_EQ(nullptr, b.get<Float>());
   EXPECT_EQ(nullptr, b.get<Int1>());
   EXPECT_EQ(&i2, b.get<Int2>());
 
TEST_F(PointerSumTypeTest, Assignment) {
   EXPECT_EQ(&i2, n.get<Int1>());
   EXPECT_EQ(nullptr, n.get<Int2>());
 
   n = SumType::create<Float>(nullptr);
   EXPECT_FALSE(n);
   EXPECT_EQ(nullptr, n.get<Float>());
   EXPECT_EQ(nullptr, n.get<Int1>());
   EXPECT_EQ(nullptr, n.get<Int2>());
+
+  d = NarrowSumType::create<EmbeddedChar>('d');
+  EXPECT_EQ(0U, d.get<EmbeddedInt1>());
+  EXPECT_EQ('d', d.get<EmbeddedChar>());
 }
 
 
 } // end anonymous namespace