Make llvm::AlignedCharArrayUnion a variadic template.

[ruiu]

Summary

Instead of a template that supports up to 10 arguments.

[dblaikie]

Looks good to me. Optional generalization of the metaprogramming if you like.

(actually, could even be generalized further by taking the test functor (max, min, etc) as another template parameter, I suppose)

include/llvm/Support/AlignOf.h

233–243

Could potentially generalize the two variadic impls to take the non-variadic as a trait, if you like?

template<template Trait<typename>, typename T, typename... Ts> struct Max {
  enum {
    X = Trait<T>::value,
    Y = Max<Trait, Ts...>::value,
    value = (X > Y) ? X : Y
  };
};
template<template Trait<typename>, typename T> struct Max<Trait, T> {
  enum { value = Trait<T>::value; };
};

template<typename T> struct SizeOf {
  enum { value = sizeof(T) };
};
template<typename T> struct AlignOf {
  enum { value = alignof(T) };
};
...
Max<SizeOf, Ts...>::value
Max<AlignOf, Ts...>::value

[ruiu]

That's interesting, but I think I wouldn't generalize it that much since we only have two templates here. If we have more that would be useful though.

[ruiu]

• Make AlignOf to take more than one arguments since there is another place that does the same thing.

[dblaikie]

include/llvm/Support/AlignOf.h

61–65

What's the need for this separate helper rather than the usual variadic template recursion+base case below?

88

I'm not sure we want to generalize the fundamental traits like this over variadic arguments & at this point would be a little more in favor of separating the variadic/max behavior from the basic trait. I don't insist on it, but wouldn't mind a 3rd opinion as it were (but I don't insist on that either). Maybe it does make sense to just make lots of traits inherently variadic if there's a single logical composition? (max rather than min, or sum, or anything else)

[ruiu]

include/llvm/Support/AlignOf.h

61–65

This is to avoid defining Alignment_GreaterEqual_* for both classes.

88

That is understandable. If this seems too much, I'll roll it back the last change so that we are not going to change AlignOf.

include/llvm/Support/AlignOf.h

 // abstract base class and the provided type. This has the same effect as the
 // above except that it handles the fact that we can't actually create a member
 // of type T.
 template <typename T>
 struct AlignmentCalcImpl<T, true> : AlignmentCalcImplBase, T {
   ~AlignmentCalcImpl() override = 0;
 };
 
+template <typename T> struct AlignOfImplOne {
+  enum {
+    Alignment = static_cast<unsigned>(sizeof(AlignmentCalcImpl<T>) - sizeof(T))
+  };
+};
+
+template <typename T, typename... Ts> struct AlignOfImpl {
+  enum {
+    X = AlignOfImplOne<T>::Alignment,
+    Y = AlignOfImpl<Ts...>::Alignment,
+    Alignment = (X > Y) ? X : Y
+  };
+};
+
+template <typename T> struct AlignOfImpl<T> {
+  enum { Alignment = AlignOfImplOne<T>::Alignment };
+};
+
 } // End detail namespace.
 
 /// AlignOf - A templated class that contains an enum value representing
 ///  the alignment of the template argument.  For example,
 ///  AlignOf<int>::Alignment represents the alignment of type "int".  The
 ///  alignment calculated is the minimum alignment, and not necessarily
 ///  the "desired" alignment returned by GCC's __alignof__ (for example).  Note
 ///  that because the alignment is an enum value, it can be used as a
 ///  compile-time constant (e.g., for template instantiation).
-template <typename T>
-struct AlignOf {
+template <typename... Ts> struct AlignOf {
 #ifndef _MSC_VER
   // Avoid warnings from GCC like:
   //   comparison between 'enum llvm::AlignOf<X>::<anonymous>' and 'enum
   //   llvm::AlignOf<Y>::<anonymous>' [-Wenum-compare]
   // by using constexpr instead of enum.
   // (except on MSVC, since it doesn't support constexpr yet).
-  static constexpr unsigned Alignment = static_cast<unsigned int>(
-      sizeof(detail::AlignmentCalcImpl<T>) - sizeof(T));
+  static constexpr unsigned Alignment = detail::AlignOfImpl<Ts...>::Alignment;
 #else
-  enum {
-    Alignment = static_cast<unsigned int>(
-        sizeof(::llvm::detail::AlignmentCalcImpl<T>) - sizeof(T))
-  };
+  enum { Alignment = detail::AlignOfImpl<Ts...>::Alignment };
 #endif
+
   enum { Alignment_GreaterEqual_2Bytes = Alignment >= 2 ? 1 : 0 };
   enum { Alignment_GreaterEqual_4Bytes = Alignment >= 4 ? 1 : 0 };
   enum { Alignment_GreaterEqual_8Bytes = Alignment >= 8 ? 1 : 0 };
   enum { Alignment_GreaterEqual_16Bytes = Alignment >= 16 ? 1 : 0 };
-
   enum { Alignment_LessEqual_2Bytes = Alignment <= 2 ? 1 : 0 };
   enum { Alignment_LessEqual_4Bytes = Alignment <= 4 ? 1 : 0 };
   enum { Alignment_LessEqual_8Bytes = Alignment <= 8 ? 1 : 0 };
   enum { Alignment_LessEqual_16Bytes = Alignment <= 16 ? 1 : 0 };
 };
 
 #ifndef _MSC_VER
-template <typename T> constexpr unsigned AlignOf<T>::Alignment;
+template <typename... Ts> constexpr unsigned AlignOf<Ts...>::Alignment;
 #endif
 
 /// alignOf - A templated function that returns the minimum alignment of
 ///  of a type.  This provides no extra functionality beyond the AlignOf
 ///  class besides some cosmetic cleanliness.  Example usage:
 ///  alignOf<int>() returns the alignment of an int.
-template <typename T>
-inline unsigned alignOf() { return AlignOf<T>::Alignment; }
+template <typename... Ts> inline unsigned alignOf() {
+  return AlignOf<Ts...>::Alignment;
+}
 
 /// \struct AlignedCharArray
 /// \brief Helper for building an aligned character array type.
 ///
 /// This template is used to explicitly build up a collection of aligned
 /// character array types. We have to build these up using a macro and explicit
 /// specialization to cope with old versions of MSVC and GCC where only an
 /// integer literal can be used to specify an alignment constraint. Once built

 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(64)
 LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(128)
 
 #undef LLVM_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT
 
 #endif // _MSC_VER
 
 namespace detail {
-template <typename T1,
-          typename T2 = char, typename T3 = char, typename T4 = char,
-          typename T5 = char, typename T6 = char, typename T7 = char,
-          typename T8 = char, typename T9 = char, typename T10 = char>
-class AlignerImpl {
-  T1 t1; T2 t2; T3 t3; T4 t4; T5 t5; T6 t6; T7 t7; T8 t8; T9 t9; T10 t10;
-
-  AlignerImpl() = delete;
-};
-
-template <typename T1,
-          typename T2 = char, typename T3 = char, typename T4 = char,
-          typename T5 = char, typename T6 = char, typename T7 = char,
-          typename T8 = char, typename T9 = char, typename T10 = char>
-union SizerImpl {
-  char arr1[sizeof(T1)], arr2[sizeof(T2)], arr3[sizeof(T3)], arr4[sizeof(T4)],
-       arr5[sizeof(T5)], arr6[sizeof(T6)], arr7[sizeof(T7)], arr8[sizeof(T8)],
-       arr9[sizeof(T9)], arr10[sizeof(T10)];
+template <typename T, typename... Ts> struct SizerImpl {
+  enum {
+    X = sizeof(T),
+    Y = SizerImpl<Ts...>::SizeOf,
+    SizeOf = (X > Y) ? X : Y
+  };
+};
+
+template <typename T> struct SizerImpl<T> {
+  enum { SizeOf = sizeof(T) };
 };
 } // end namespace detail
 
 /// \brief This union template exposes a suitably aligned and sized character
 /// array member which can hold elements of any of up to ten types.
 ///
 /// These types may be arrays, structs, or any other types. The goal is to
 /// expose a char array buffer member which can be used as suitable storage for
-/// a placement new of any of these types. Support for more than ten types can
-/// be added at the cost of more boilerplate.
-template <typename T1,
-          typename T2 = char, typename T3 = char, typename T4 = char,
-          typename T5 = char, typename T6 = char, typename T7 = char,
-          typename T8 = char, typename T9 = char, typename T10 = char>
-struct AlignedCharArrayUnion : llvm::AlignedCharArray<
-    AlignOf<llvm::detail::AlignerImpl<T1, T2, T3, T4, T5,
-                                      T6, T7, T8, T9, T10> >::Alignment,
-    sizeof(::llvm::detail::SizerImpl<T1, T2, T3, T4, T5,
-                                     T6, T7, T8, T9, T10>)> {
-};
+/// a placement new of any of these types.
+template <typename... Ts>
+using AlignedCharArrayUnion =
+    llvm::AlignedCharArray<AlignOf<Ts...>::Alignment,
+                           llvm::detail::SizerImpl<Ts...>::SizeOf>;
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_ALIGNOF_H

include/llvm/Support/TrailingObjects.h

 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/type_traits.h"
 #include <new>
 #include <type_traits>
 
 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.)

 
 } // 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...> {
+class TrailingObjects
+    : private trailing_objects_internal::TrailingObjectsImpl<
+          AlignOf<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...>
+      AlignOf<TrailingTys...>::Alignment, BaseTy,
+      TrailingObjects<BaseTy, TrailingTys...>, BaseTy, TrailingTys...>
       ParentType;
   using TrailingObjectsBase = trailing_objects_internal::TrailingObjectsBase;
 
   using ParentType::getTrailingObjectsImpl;
 
   // This function contains only a static_assert BaseTy is final. The
   // static_assert must be in a function, and not at class-level
   // because BaseTy isn't complete at class instantiation time, but