X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=include%2Fllvm%2FSupport%2FTrailingObjects.h;h=02dfad7954a541b6ee349140e5e1892580dc4330;hp=a8a9bb2592f4fefbfac81622a6301b44379c1cd8;hb=ca5c277bdf14f18f69ef36ef43f350e95a20f69b;hpb=ecd3b686c16a76758f2187a71dda392340e77e92 diff --git a/include/llvm/Support/TrailingObjects.h b/include/llvm/Support/TrailingObjects.h index a8a9bb2592f..02dfad7954a 100644 --- a/include/llvm/Support/TrailingObjects.h +++ b/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 @@ protected: 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 {}; +/// 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 { +}; -// TODO: Consider using a single variadic implementation instead of -// multiple copies of the TrailingObjects template? [but, variadic -// template recursive implementations are annoying...] +// 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; -/// This is the two-type version of the TrailingObjects template; see -/// file docstring for details. -template -class TrailingObjects : public TrailingObjectsBase { -private: // 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 @@ protected: 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 @@ protected: 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 @@ protected: /// 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...); } };