Rewrite the TrailingObjects template to provide two new features:

[jyknight]

Summary

• Automatic alignment of the base type for the alignment requirements of the trailing types.
• Support for an arbitrary numbers of trailing types, instead of only 1 or 2, by using a variadic template implementation.

[jyknight]

ping.

[jyknight]

I've been letting this lie for a while, since I'd not been working on this, but I'd like restart and finish this project.

So, ping. :)

llvm/trunk/include/llvm/Support/TrailingObjects.h

 #include <new>
 #include <type_traits>
 #include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/type_traits.h"
 
 namespace llvm {
 
+namespace trailing_objects_internal {
+/// Helper template to calculate the max alignment requirement for a set of
+/// objects.
+template <typename First, typename... Rest> class AlignmentCalcHelper {
+private:
+  enum {
+    FirstAlignment = AlignOf<First>::Alignment,
+    RestAlignment = AlignmentCalcHelper<Rest...>::Alignment,
+  };
+
+public:
+  enum {
+    Alignment = FirstAlignment > RestAlignment ? FirstAlignment : RestAlignment
+  };
+};
+
+template <typename First> class AlignmentCalcHelper<First> {
+public:
+  enum { Alignment = AlignOf<First>::Alignment };
+};
+
 /// The base class for TrailingObjects* classes.
 class TrailingObjectsBase {
 protected:
   /// OverloadToken's purpose is to allow specifying function overloads
   /// for different types, without actually taking the types as
   /// parameters. (Necessary because member function templates cannot
   /// be specialized, so overloads must be used instead of
   /// specialization.)
   template <typename T> struct OverloadToken {};
 };
 
-// Internally used to indicate that the user didn't supply this value,
-// so the explicit-specialization for fewer args will be used.
-class NoTrailingTypeArg {};
-
-// TODO: Consider using a single variadic implementation instead of
-// multiple copies of the TrailingObjects template? [but, variadic
-// template recursive implementations are annoying...]
-
-/// This is the two-type version of the TrailingObjects template; see
-/// file docstring for details.
-template <typename BaseTy, typename TrailingTy1,
-          typename TrailingTy2 = NoTrailingTypeArg>
-class TrailingObjects : public TrailingObjectsBase {
-private:
+/// This helper template works-around MSVC 2013's lack of useful
+/// alignas() support. The argument to LLVM_ALIGNAS(), in MSVC, is
+/// required to be a literal integer. But, you *can* use template
+/// specialization to select between a bunch of different LLVM_ALIGNAS
+/// expressions...
+template <int Align>
+class TrailingObjectsAligner : public TrailingObjectsBase {};
+template <>
+class LLVM_ALIGNAS(1) TrailingObjectsAligner<1> : public TrailingObjectsBase {};
+template <>
+class LLVM_ALIGNAS(2) TrailingObjectsAligner<2> : public TrailingObjectsBase {};
+template <>
+class LLVM_ALIGNAS(4) TrailingObjectsAligner<4> : public TrailingObjectsBase {};
+template <>
+class LLVM_ALIGNAS(8) TrailingObjectsAligner<8> : public TrailingObjectsBase {};
+template <>
+class LLVM_ALIGNAS(16) TrailingObjectsAligner<16> : public TrailingObjectsBase {
+};
+template <>
+class LLVM_ALIGNAS(32) TrailingObjectsAligner<32> : public TrailingObjectsBase {
+};
+
+// Just a little helper for transforming a type pack into the same
+// number of a different type. e.g.:
+//   ExtractSecondType<Foo..., int>::type
+template <typename Ty1, typename Ty2> struct ExtractSecondType {
+  typedef Ty2 type;
+};
+
+// TrailingObjectsImpl is somewhat complicated, because it is a
+// recursively inheriting template, in order to handle the template
+// varargs. Each level of inheritance picks off a single trailing type
+// then recurses on the rest. The "Align", "BaseTy", and
+// "TopTrailingObj" arguments are passed through unchanged through the
+// recursion. "PrevTy" is, at each level, the type handled by the
+// level right above it.
+
+template <int Align, typename BaseTy, typename TopTrailingObj, typename PrevTy,
+          typename... MoreTys>
+struct TrailingObjectsImpl {
+  // The main template definition is never used -- the two
+  // specializations cover all possibilities.
+};
+
+template <int Align, typename BaseTy, typename TopTrailingObj, typename PrevTy,
+          typename NextTy, typename... MoreTys>
+struct TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, PrevTy, NextTy,
+                           MoreTys...>
+    : public TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, NextTy,
+                                 MoreTys...> {
+
+  typedef TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, NextTy, MoreTys...>
+      ParentType;
+
+  // Ensure the methods we inherit are not hidden.
+  using ParentType::getTrailingObjectsImpl;
+  using ParentType::additionalSizeToAllocImpl;
+
+  static void verifyTrailingObjectsAssertions() {
+    static_assert(llvm::AlignOf<PrevTy>::Alignment >=
+                      llvm::AlignOf<NextTy>::Alignment,
+                  "A trailing object requires more alignment than the previous "
+                  "trailing object provides");
+
+    ParentType::verifyTrailingObjectsAssertions();
+  }
+
+  // These two functions are helper functions for
+  // TrailingObjects::getTrailingObjects. They recurse to the left --
+  // the result for each type in the list of trailing types depends on
+  // the result of calling the function on the type to the
+  // left. However, the function for the type to the left is
+  // implemented by a *subclass* of this class, so we invoke it via
+  // the TopTrailingObj, which is, via the
+  // curiously-recurring-template-pattern, the most-derived type in
+  // this recursion, and thus, contains all the overloads.
+  static const NextTy *
+  getTrailingObjectsImpl(const BaseTy *Obj,
+                         TrailingObjectsBase::OverloadToken<NextTy>) {
+    return reinterpret_cast<const NextTy *>(
+        TopTrailingObj::getTrailingObjectsImpl(
+            Obj, TrailingObjectsBase::OverloadToken<PrevTy>()) +
+        TopTrailingObj::callNumTrailingObjects(
+            Obj, TrailingObjectsBase::OverloadToken<PrevTy>()));
+  }
+
+  static NextTy *
+  getTrailingObjectsImpl(BaseTy *Obj,
+                         TrailingObjectsBase::OverloadToken<NextTy>) {
+    return reinterpret_cast<NextTy *>(
+        TopTrailingObj::getTrailingObjectsImpl(
+            Obj, TrailingObjectsBase::OverloadToken<PrevTy>()) +
+        TopTrailingObj::callNumTrailingObjects(
+            Obj, TrailingObjectsBase::OverloadToken<PrevTy>()));
+  }
+
+  // Helper function for TrailingObjects::additionalSizeToAlloc: this
+  // function recurses to superclasses, each of which requires one
+  // fewer size_t argument, and adds its own size.
+  static LLVM_CONSTEXPR size_t additionalSizeToAllocImpl(
+      size_t Count1,
+      typename ExtractSecondType<MoreTys, size_t>::type... MoreCounts) {
+    return sizeof(NextTy) * Count1 + additionalSizeToAllocImpl(MoreCounts...);
+  }
+};
+
+// The base case of the TrailingObjectsImpl inheritance recursion,
+// when there's no more trailing types.
+template <int Align, typename BaseTy, typename TopTrailingObj, typename PrevTy>
+struct TrailingObjectsImpl<Align, BaseTy, TopTrailingObj, PrevTy>
+    : public TrailingObjectsAligner<Align> {
+  // This is a dummy method, only here so the "using" doesn't fail --
+  // it will never be called, because this function recurses backwards
+  // up the inheritance chain to subclasses.
+  static void getTrailingObjectsImpl();
+
+  static LLVM_CONSTEXPR size_t additionalSizeToAllocImpl() { return 0; }
+
+  static void verifyTrailingObjectsAssertions() {}
+};
+
+} // end namespace trailing_objects_internal
+
+// Finally, the main type defined in this file, the one intended for users...
+
+/// See the file comment for details on the usage of the
+/// TrailingObjects type.
+template <typename BaseTy, typename... TrailingTys>
+class TrailingObjects : private trailing_objects_internal::TrailingObjectsImpl<
+                            trailing_objects_internal::AlignmentCalcHelper<
+                                TrailingTys...>::Alignment,
+                            BaseTy, TrailingObjects<BaseTy, TrailingTys...>,
+                            BaseTy, TrailingTys...> {
+
+  template <int A, typename B, typename T, typename P, typename... M>
+  friend struct trailing_objects_internal::TrailingObjectsImpl;
+
+  template <typename... Tys> class Foo {};
+
+  typedef trailing_objects_internal::TrailingObjectsImpl<
+      trailing_objects_internal::AlignmentCalcHelper<TrailingTys...>::Alignment,
+      BaseTy, TrailingObjects<BaseTy, TrailingTys...>, BaseTy, TrailingTys...>
+      ParentType;
+  using TrailingObjectsBase = trailing_objects_internal::TrailingObjectsBase;
+
+  using ParentType::getTrailingObjectsImpl;
+
   // Contains static_assert statements for the alignment of the
   // types. Must not be at class-level, because BaseTy isn't complete
   // at class instantiation time, but will be by the time this
-  // function is instantiated.
+  // function is instantiated. Recurses through the superclasses.
   static void verifyTrailingObjectsAssertions() {
-    static_assert(llvm::AlignOf<BaseTy>::Alignment >=
-                      llvm::AlignOf<TrailingTy1>::Alignment,
-                  "TrailingTy1 requires more alignment than BaseTy provides");
-    static_assert(
-        llvm::AlignOf<TrailingTy1>::Alignment >=
-            llvm::AlignOf<TrailingTy2>::Alignment,
-        "TrailingTy2 requires more alignment than TrailingTy1 provides");
-
 #ifdef LLVM_IS_FINAL
     static_assert(LLVM_IS_FINAL(BaseTy), "BaseTy must be final.");
 #endif
+    ParentType::verifyTrailingObjectsAssertions();
   }
 
-  // The next four functions are internal helpers for getTrailingObjects.
-  static const TrailingTy1 *getTrailingObjectsImpl(const BaseTy *Obj,
-                                                   OverloadToken<TrailingTy1>) {
-    return reinterpret_cast<const TrailingTy1 *>(Obj + 1);
+  // These two methods are the base of the recursion for this method.
+  static const BaseTy *
+  getTrailingObjectsImpl(const BaseTy *Obj,
+                         TrailingObjectsBase::OverloadToken<BaseTy>) {
+    return Obj;
   }
 
-  static TrailingTy1 *getTrailingObjectsImpl(BaseTy *Obj,
-                                             OverloadToken<TrailingTy1>) {
-    return reinterpret_cast<TrailingTy1 *>(Obj + 1);
+  static BaseTy *
+  getTrailingObjectsImpl(BaseTy *Obj,
+                         TrailingObjectsBase::OverloadToken<BaseTy>) {
+    return Obj;
   }
 
-  static const TrailingTy2 *getTrailingObjectsImpl(const BaseTy *Obj,
-                                                   OverloadToken<TrailingTy2>) {
-    return reinterpret_cast<const TrailingTy2 *>(
-        getTrailingObjectsImpl(Obj, OverloadToken<TrailingTy1>()) +
-        Obj->numTrailingObjects(OverloadToken<TrailingTy1>()));
+  // callNumTrailingObjects simply calls numTrailingObjects on the
+  // provided Obj -- except when the type being queried is BaseTy
+  // itself. There is always only one of the base object, so that case
+  // is handled here. (An additional benefit of indirecting through
+  // this function is that consumers only say "friend
+  // TrailingObjects", and thus, only this class itself can call the
+  // numTrailingObjects function.)
+  static size_t
+  callNumTrailingObjects(const BaseTy *Obj,
+                         TrailingObjectsBase::OverloadToken<BaseTy>) {
+    return 1;
   }
 
-  static TrailingTy2 *getTrailingObjectsImpl(BaseTy *Obj,
-                                             OverloadToken<TrailingTy2>) {
-    return reinterpret_cast<TrailingTy2 *>(
-        getTrailingObjectsImpl(Obj, OverloadToken<TrailingTy1>()) +
-        Obj->numTrailingObjects(OverloadToken<TrailingTy1>()));
+  template <typename T>
+  static size_t callNumTrailingObjects(const BaseTy *Obj,
+                                       TrailingObjectsBase::OverloadToken<T>) {
+    return Obj->numTrailingObjects(TrailingObjectsBase::OverloadToken<T>());
   }
 
-protected:
+public:
+  // make this (privately inherited) class public.
+  using TrailingObjectsBase::OverloadToken;
+
   /// Returns a pointer to the trailing object array of the given type
   /// (which must be one of those specified in the class template). The
   /// array may have zero or more elements in it.
   template <typename T> const T *getTrailingObjects() const {
     verifyTrailingObjectsAssertions();
     // Forwards to an impl function with overloads, since member
     // function templates can't be specialized.
-    return getTrailingObjectsImpl(static_cast<const BaseTy *>(this),
-                                  OverloadToken<T>());
+    return this->getTrailingObjectsImpl(
+        static_cast<const BaseTy *>(this),
+        TrailingObjectsBase::OverloadToken<T>());
   }
 
   /// Returns a pointer to the trailing object array of the given type
   /// (which must be one of those specified in the class template). The
   /// array may have zero or more elements in it.
   template <typename T> T *getTrailingObjects() {
     verifyTrailingObjectsAssertions();
     // Forwards to an impl function with overloads, since member
     // function templates can't be specialized.
-    return getTrailingObjectsImpl(static_cast<BaseTy *>(this),
-                                  OverloadToken<T>());
+    return this->getTrailingObjectsImpl(
+        static_cast<BaseTy *>(this), TrailingObjectsBase::OverloadToken<T>());
   }
 
   /// Returns the size of the trailing data, if an object were
   /// allocated with the given counts (The counts are in the same order
   /// as the template arguments). This does not include the size of the
   /// base object.  The template arguments must be the same as those
   /// used in the class; they are supplied here redundantly only so
   /// that it's clear what the counts are counting in callers.
-  template <typename Ty1, typename Ty2,
-            typename std::enable_if<std::is_same<Ty1, TrailingTy1>::value &&
-                                        std::is_same<Ty2, TrailingTy2>::value,
-                                    int>::type = 0>
-  static LLVM_CONSTEXPR size_t additionalSizeToAlloc(size_t Count1, size_t Count2) {
-    return sizeof(TrailingTy1) * Count1 + sizeof(TrailingTy2) * Count2;
+  template <typename... Tys>
+  static LLVM_CONSTEXPR typename std::enable_if<
+      std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>::type
+      additionalSizeToAlloc(
+          typename trailing_objects_internal::ExtractSecondType<
+              TrailingTys, size_t>::type... Counts) {
+    return ParentType::additionalSizeToAllocImpl(Counts...);
   }
 
   /// Returns the total size of an object if it were allocated with the
   /// given trailing object counts. This is the same as
   /// additionalSizeToAlloc, except it *does* include the size of the base
   /// object.
-  template <typename Ty1, typename Ty2>
-  static LLVM_CONSTEXPR size_t totalSizeToAlloc(size_t Count1, size_t Count2) {
-    return sizeof(BaseTy) + additionalSizeToAlloc<Ty1, Ty2>(Count1, Count2);
-  }
-};
-
-/// This is the one-type version of the TrailingObjects template. See
-/// the two-type version for more documentation.
-template <typename BaseTy, typename TrailingTy1>
-class TrailingObjects<BaseTy, TrailingTy1, NoTrailingTypeArg>
-    : public TrailingObjectsBase {
-private:
-  static void verifyTrailingObjectsAssertions() {
-    static_assert(llvm::AlignOf<BaseTy>::Alignment >=
-                      llvm::AlignOf<TrailingTy1>::Alignment,
-                  "TrailingTy1 requires more alignment than BaseTy provides");
-
-#ifdef LLVM_IS_FINAL
-    static_assert(LLVM_IS_FINAL(BaseTy), "BaseTy must be final.");
-#endif
-  }
-
-  static const TrailingTy1 *getTrailingObjectsImpl(const BaseTy *Obj,
-                                                   OverloadToken<TrailingTy1>) {
-    return reinterpret_cast<const TrailingTy1 *>(Obj + 1);
-  }
-
-  static TrailingTy1 *getTrailingObjectsImpl(BaseTy *Obj,
-                                             OverloadToken<TrailingTy1>) {
-    return reinterpret_cast<TrailingTy1 *>(Obj + 1);
-  }
-
-protected:
-  template <typename T> const T *getTrailingObjects() const {
-    verifyTrailingObjectsAssertions();
-    return getTrailingObjectsImpl(static_cast<const BaseTy *>(this),
-                                  OverloadToken<T>());
-  }
-
-  template <typename T> T *getTrailingObjects() {
-    verifyTrailingObjectsAssertions();
-    return getTrailingObjectsImpl(static_cast<BaseTy *>(this),
-                                  OverloadToken<T>());
-  }
-
-  template <typename Ty1,
-            typename std::enable_if<std::is_same<Ty1, TrailingTy1>::value,
-                                    int>::type = 0>
-  static LLVM_CONSTEXPR size_t additionalSizeToAlloc(size_t Count1) {
-    return sizeof(TrailingTy1) * Count1;
-  }
-
-  template <typename Ty1>
-  static LLVM_CONSTEXPR size_t totalSizeToAlloc(size_t Count1) {
-    return sizeof(BaseTy) + additionalSizeToAlloc<Ty1>(Count1);
+  template <typename... Tys>
+  static LLVM_CONSTEXPR typename std::enable_if<
+      std::is_same<Foo<TrailingTys...>, Foo<Tys...>>::value, size_t>::type
+      totalSizeToAlloc(typename trailing_objects_internal::ExtractSecondType<
+                       TrailingTys, size_t>::type... Counts) {
+    return sizeof(BaseTy) + ParentType::additionalSizeToAllocImpl(Counts...);
   }
 };
 
 } // end namespace llvm
 
 #endif

llvm/trunk/unittests/Support/TrailingObjectsTest.cpp

public:
   unsigned numShorts() const { return NumShorts; }
 
   // Pull some protected members in as public, for testability.
   using TrailingObjects::totalSizeToAlloc;
   using TrailingObjects::additionalSizeToAlloc;
   using TrailingObjects::getTrailingObjects;
 };
 
-// Here, there are two singular optional object types appended.
-// Note that it fails to compile without the alignment spec.
-class LLVM_ALIGNAS(8) Class2 final : protected TrailingObjects<Class2, double, short> {
+// Here, there are two singular optional object types appended.  Note
+// that the alignment of Class2 is automatically increased to account
+// for the alignment requirements of the trailing objects.
+class Class2 final : protected TrailingObjects<Class2, double, short> {
   friend TrailingObjects;
 
   bool HasShort, HasDouble;
 
 protected:
   size_t numTrailingObjects(OverloadToken<short>) const {
     return HasShort ? 1 : 0;
   }
TEST(TrailingObjects, OneArg) {
   EXPECT_EQ(C->get(2), 3);
   delete C;
 }
 
 TEST(TrailingObjects, TwoArg) {
   Class2 *C1 = Class2::create(4);
   Class2 *C2 = Class2::create(0, 4.2);
 
-  EXPECT_EQ(sizeof(Class2), 8u); // due to alignment
+  EXPECT_EQ(sizeof(Class2), llvm::RoundUpToAlignment(sizeof(bool) * 2,
+                                                     llvm::alignOf<double>()));
+  EXPECT_EQ(llvm::alignOf<Class2>(), llvm::alignOf<double>());
 
   EXPECT_EQ((Class2::additionalSizeToAlloc<double, short>(1, 0)),
             sizeof(double));
   EXPECT_EQ((Class2::additionalSizeToAlloc<double, short>(0, 1)),
             sizeof(short));
   EXPECT_EQ((Class2::additionalSizeToAlloc<double, short>(3, 1)),
             sizeof(double) * 3 + sizeof(short));
 
TEST(TrailingObjects, TwoArg) {
   EXPECT_EQ(C2->getShort(), 0);
   EXPECT_EQ(C2->getTrailingObjects<double>(),
             reinterpret_cast<double *>(C2 + 1));
   EXPECT_EQ(C2->getTrailingObjects<short>(),
             reinterpret_cast<short *>(reinterpret_cast<double *>(C2 + 1) + 1));
   delete C1;
   delete C2;
 }
+
+// This test class is not trying to be a usage demo, just asserting
+// that three args does actually work too (it's the same code as
+// handles the second arg, so it's basically covered by the above, but
+// just in case..)
+class Class3 final : public TrailingObjects<Class3, double, short, bool> {
+  friend TrailingObjects;
+
+  size_t numTrailingObjects(OverloadToken<double>) const { return 1; }
+  size_t numTrailingObjects(OverloadToken<short>) const { return 1; }
+};
+
+TEST(TrailingObjects, ThreeArg) {
+  EXPECT_EQ((Class3::additionalSizeToAlloc<double, short, bool>(1, 1, 3)),
+            sizeof(double) + sizeof(short) + 3 * sizeof(bool));
+  EXPECT_EQ(sizeof(Class3),
+            llvm::RoundUpToAlignment(1, llvm::alignOf<double>()));
+  Class3 *C = reinterpret_cast<Class3 *>(::operator new(1000));
+  EXPECT_EQ(C->getTrailingObjects<double>(), reinterpret_cast<double *>(C + 1));
+  EXPECT_EQ(C->getTrailingObjects<short>(),
+            reinterpret_cast<short *>(reinterpret_cast<double *>(C + 1) + 1));
+  EXPECT_EQ(
+      C->getTrailingObjects<bool>(),
+      reinterpret_cast<bool *>(
+          reinterpret_cast<short *>(reinterpret_cast<double *>(C + 1) + 1) +
+          1));
+}
 }