Index: llvm/trunk/include/llvm/Support/TrailingObjects.h =================================================================== --- llvm/trunk/include/llvm/Support/TrailingObjects.h +++ llvm/trunk/include/llvm/Support/TrailingObjects.h @@ -59,6 +59,27 @@ namespace llvm { +namespace trailing_objects_internal { +/// Helper template to calculate the max alignment requirement for a set of +/// objects. +template class AlignmentCalcHelper { +private: + enum { + FirstAlignment = AlignOf::Alignment, + RestAlignment = AlignmentCalcHelper::Alignment, + }; + +public: + enum { + Alignment = FirstAlignment > RestAlignment ? FirstAlignment : RestAlignment + }; +}; + +template class AlignmentCalcHelper { +public: + enum { Alignment = AlignOf::Alignment }; +}; + /// The base class for TrailingObjects* classes. class TrailingObjectsBase { protected: @@ -70,64 +91,200 @@ template 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 -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 +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::type +template 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 +struct TrailingObjectsImpl { + // The main template definition is never used -- the two + // specializations cover all possibilities. +}; + +template +struct TrailingObjectsImpl + : public TrailingObjectsImpl { + + typedef TrailingObjectsImpl + ParentType; + + // Ensure the methods we inherit are not hidden. + using ParentType::getTrailingObjectsImpl; + using ParentType::additionalSizeToAllocImpl; + + static void verifyTrailingObjectsAssertions() { + static_assert(llvm::AlignOf::Alignment >= + llvm::AlignOf::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) { + return reinterpret_cast( + TopTrailingObj::getTrailingObjectsImpl( + Obj, TrailingObjectsBase::OverloadToken()) + + TopTrailingObj::callNumTrailingObjects( + Obj, TrailingObjectsBase::OverloadToken())); + } + + static NextTy * + getTrailingObjectsImpl(BaseTy *Obj, + TrailingObjectsBase::OverloadToken) { + return reinterpret_cast( + TopTrailingObj::getTrailingObjectsImpl( + Obj, TrailingObjectsBase::OverloadToken()) + + TopTrailingObj::callNumTrailingObjects( + Obj, TrailingObjectsBase::OverloadToken())); + } + + // 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::type... MoreCounts) { + return sizeof(NextTy) * Count1 + additionalSizeToAllocImpl(MoreCounts...); + } +}; + +// The base case of the TrailingObjectsImpl inheritance recursion, +// when there's no more trailing types. +template +struct TrailingObjectsImpl + : public TrailingObjectsAligner { + // 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 +class TrailingObjects : private trailing_objects_internal::TrailingObjectsImpl< + trailing_objects_internal::AlignmentCalcHelper< + TrailingTys...>::Alignment, + BaseTy, TrailingObjects, + BaseTy, TrailingTys...> { + + template + friend struct trailing_objects_internal::TrailingObjectsImpl; + + template class Foo {}; + + typedef trailing_objects_internal::TrailingObjectsImpl< + trailing_objects_internal::AlignmentCalcHelper::Alignment, + BaseTy, TrailingObjects, 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::Alignment >= - llvm::AlignOf::Alignment, - "TrailingTy1 requires more alignment than BaseTy provides"); - static_assert( - llvm::AlignOf::Alignment >= - llvm::AlignOf::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) { - return reinterpret_cast(Obj + 1); + // These two methods are the base of the recursion for this method. + static const BaseTy * + getTrailingObjectsImpl(const BaseTy *Obj, + TrailingObjectsBase::OverloadToken) { + return Obj; } - static TrailingTy1 *getTrailingObjectsImpl(BaseTy *Obj, - OverloadToken) { - return reinterpret_cast(Obj + 1); + static BaseTy * + getTrailingObjectsImpl(BaseTy *Obj, + TrailingObjectsBase::OverloadToken) { + return Obj; } - static const TrailingTy2 *getTrailingObjectsImpl(const BaseTy *Obj, - OverloadToken) { - return reinterpret_cast( - getTrailingObjectsImpl(Obj, OverloadToken()) + - Obj->numTrailingObjects(OverloadToken())); + // 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) { + return 1; } - static TrailingTy2 *getTrailingObjectsImpl(BaseTy *Obj, - OverloadToken) { - return reinterpret_cast( - getTrailingObjectsImpl(Obj, OverloadToken()) + - Obj->numTrailingObjects(OverloadToken())); + template + static size_t callNumTrailingObjects(const BaseTy *Obj, + TrailingObjectsBase::OverloadToken) { + return Obj->numTrailingObjects(TrailingObjectsBase::OverloadToken()); } -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. @@ -135,8 +292,9 @@ verifyTrailingObjectsAssertions(); // Forwards to an impl function with overloads, since member // function templates can't be specialized. - return getTrailingObjectsImpl(static_cast(this), - OverloadToken()); + return this->getTrailingObjectsImpl( + static_cast(this), + TrailingObjectsBase::OverloadToken()); } /// Returns a pointer to the trailing object array of the given type @@ -146,8 +304,8 @@ verifyTrailingObjectsAssertions(); // Forwards to an impl function with overloads, since member // function templates can't be specialized. - return getTrailingObjectsImpl(static_cast(this), - OverloadToken()); + return this->getTrailingObjectsImpl( + static_cast(this), TrailingObjectsBase::OverloadToken()); } /// Returns the size of the trailing data, if an object were @@ -156,73 +314,25 @@ /// 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 ::value && - std::is_same::value, - int>::type = 0> - static LLVM_CONSTEXPR size_t additionalSizeToAlloc(size_t Count1, size_t Count2) { - return sizeof(TrailingTy1) * Count1 + sizeof(TrailingTy2) * Count2; + template + static LLVM_CONSTEXPR typename std::enable_if< + std::is_same, Foo>::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 - static LLVM_CONSTEXPR size_t totalSizeToAlloc(size_t Count1, size_t Count2) { - return sizeof(BaseTy) + additionalSizeToAlloc(Count1, Count2); - } -}; - -/// This is the one-type version of the TrailingObjects template. See -/// the two-type version for more documentation. -template -class TrailingObjects - : public TrailingObjectsBase { -private: - static void verifyTrailingObjectsAssertions() { - static_assert(llvm::AlignOf::Alignment >= - llvm::AlignOf::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) { - return reinterpret_cast(Obj + 1); - } - - static TrailingTy1 *getTrailingObjectsImpl(BaseTy *Obj, - OverloadToken) { - return reinterpret_cast(Obj + 1); - } - -protected: - template const T *getTrailingObjects() const { - verifyTrailingObjectsAssertions(); - return getTrailingObjectsImpl(static_cast(this), - OverloadToken()); - } - - template T *getTrailingObjects() { - verifyTrailingObjectsAssertions(); - return getTrailingObjectsImpl(static_cast(this), - OverloadToken()); - } - - template ::value, - int>::type = 0> - static LLVM_CONSTEXPR size_t additionalSizeToAlloc(size_t Count1) { - return sizeof(TrailingTy1) * Count1; - } - - template - static LLVM_CONSTEXPR size_t totalSizeToAlloc(size_t Count1) { - return sizeof(BaseTy) + additionalSizeToAlloc(Count1); + template + static LLVM_CONSTEXPR typename std::enable_if< + std::is_same, Foo>::value, size_t>::type + totalSizeToAlloc(typename trailing_objects_internal::ExtractSecondType< + TrailingTys, size_t>::type... Counts) { + return sizeof(BaseTy) + ParentType::additionalSizeToAllocImpl(Counts...); } }; Index: llvm/trunk/unittests/Support/TrailingObjectsTest.cpp =================================================================== --- llvm/trunk/unittests/Support/TrailingObjectsTest.cpp +++ llvm/trunk/unittests/Support/TrailingObjectsTest.cpp @@ -45,9 +45,10 @@ 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 { +// 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 { friend TrailingObjects; bool HasShort, HasDouble; @@ -117,7 +118,9 @@ 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())); + EXPECT_EQ(llvm::alignOf(), llvm::alignOf()); EXPECT_EQ((Class2::additionalSizeToAlloc(1, 0)), sizeof(double)); @@ -144,4 +147,31 @@ 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 { + friend TrailingObjects; + + size_t numTrailingObjects(OverloadToken) const { return 1; } + size_t numTrailingObjects(OverloadToken) const { return 1; } +}; + +TEST(TrailingObjects, ThreeArg) { + EXPECT_EQ((Class3::additionalSizeToAlloc(1, 1, 3)), + sizeof(double) + sizeof(short) + 3 * sizeof(bool)); + EXPECT_EQ(sizeof(Class3), + llvm::RoundUpToAlignment(1, llvm::alignOf())); + Class3 *C = reinterpret_cast(::operator new(1000)); + EXPECT_EQ(C->getTrailingObjects(), reinterpret_cast(C + 1)); + EXPECT_EQ(C->getTrailingObjects(), + reinterpret_cast(reinterpret_cast(C + 1) + 1)); + EXPECT_EQ( + C->getTrailingObjects(), + reinterpret_cast( + reinterpret_cast(reinterpret_cast(C + 1) + 1) + + 1)); +} }