Subject: [Boost-commit] svn:boost r50559 - in trunk: boost/type_traits libs/type_traits/test
From: john_at_[hidden]
Date: 2009-01-13 07:49:43
Author: johnmaddock
Date: 2009-01-13 07:49:42 EST (Tue, 13 Jan 2009)
New Revision: 50559
URL: http://svn.boost.org/trac/boost/changeset/50559
Log:
Fix msvc regression and add additional tests to check issue #1946 fix.
Added:
trunk/libs/type_traits/test/aligned_storage_test_a2.cpp (contents, props changed)
trunk/libs/type_traits/test/alignment_of_test_a2.cpp (contents, props changed)
Text files modified:
trunk/boost/type_traits/alignment_of.hpp | 13 ++++++++++++-
1 files changed, 12 insertions(+), 1 deletions(-)
Modified: trunk/boost/type_traits/alignment_of.hpp
==============================================================================
--- trunk/boost/type_traits/alignment_of.hpp (original)
+++ trunk/boost/type_traits/alignment_of.hpp 2009-01-13 07:49:42 EST (Tue, 13 Jan 2009)
@@ -56,7 +56,18 @@
template< typename T >
struct alignment_of_impl
{
-#ifndef BOOST_ALIGNMENT_OF
+#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
+ //
+ // With MSVC both the native __alignof operator
+ // and our own logic gets things wrong from time to time :-(
+ // Using a combination of the two seems to make the most of a bad job:
+ //
+ BOOST_STATIC_CONSTANT(std::size_t, value =
+ (::boost::detail::alignment_logic<
+ sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
+ __alignof(T)
+ >::value));
+#elif !defined(BOOST_ALIGNMENT_OF)
BOOST_STATIC_CONSTANT(std::size_t, value =
(::boost::detail::alignment_logic<
sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T),
Added: trunk/libs/type_traits/test/aligned_storage_test_a2.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/type_traits/test/aligned_storage_test_a2.cpp 2009-01-13 07:49:42 EST (Tue, 13 Jan 2009)
@@ -0,0 +1,113 @@
+
+#ifdef _MSC_VER
+#pragma pack(2)
+#endif
+
+// (C) Copyright John Maddock 2000.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+#ifdef TEST_STD
+# include <type_traits>
+# include <boost/type_traits/type_with_alignment.hpp> // max_align and long_long_type
+#else
+# include <boost/type_traits/alignment_of.hpp>
+# include <boost/type_traits/aligned_storage.hpp>
+# include <boost/type_traits/is_pod.hpp>
+#endif
+
+template <class T>
+union must_be_pod
+{
+ int i;
+ T t;
+};
+
+template <class T>
+inline void no_unused_warning(const volatile T&)
+{
+}
+
+template <class T>
+void check(const T&)
+{
+ typedef typename tt::aligned_storage<T::value,T::value>::type t1;
+ t1 as1 = { 0, };
+ must_be_pod<t1> pod1;
+ no_unused_warning(as1);
+ no_unused_warning(pod1);
+ BOOST_MESSAGE(typeid(t1).name());
+ BOOST_CHECK(::tt::alignment_of<t1>::value == T::value);
+ BOOST_CHECK(sizeof(t1) == T::value);
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ BOOST_CHECK(::tt::is_pod<t1>::value == true);
+#endif
+ typedef typename tt::aligned_storage<T::value*2,T::value>::type t2;
+ t2 as2 = { 0, };
+ must_be_pod<t2> pod2;
+ no_unused_warning(as2);
+ no_unused_warning(pod2);
+ BOOST_MESSAGE(typeid(t2).name());
+ BOOST_CHECK(::tt::alignment_of<t2>::value == T::value);
+ BOOST_CHECK(sizeof(t2) == T::value*2);
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ BOOST_CHECK(::tt::is_pod<t2>::value == true);
+#endif
+
+#ifndef TEST_STD
+ // Non-Tr1 behaviour:
+ typedef typename tt::aligned_storage<T::value,-1L>::type t3;
+ t3 as3 = { 0, };
+ must_be_pod<t3> pod3;
+ no_unused_warning(as3);
+ no_unused_warning(pod3);
+ BOOST_MESSAGE(typeid(t3).name());
+ BOOST_CHECK(::tt::alignment_of<t3>::value == ::tt::alignment_of< ::boost::detail::max_align>::value);
+ BOOST_CHECK((sizeof(t3) % T::value) == 0);
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ BOOST_CHECK(::tt::is_pod<t3>::value == true);
+#endif
+#endif
+}
+
+TT_TEST_BEGIN(type_with_alignment)
+
+check(tt::integral_constant<std::size_t,::tt::alignment_of<char>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<short>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<int>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<long>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<float>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<double>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<long double>::value>());
+
+#ifdef BOOST_HAS_LONG_LONG
+check(tt::integral_constant<std::size_t,::tt::alignment_of< ::boost::long_long_type>::value>());
+#endif
+#ifdef BOOST_HAS_MS_INT64
+check(tt::integral_constant<std::size_t,::tt::alignment_of<__int64>::value>());
+#endif
+check(tt::integral_constant<std::size_t,::tt::alignment_of<int[4]>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<int(*)(int)>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<int*>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<VB>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<VD>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<enum_UDT>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<mf2>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<POD_UDT>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<empty_UDT>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<union_UDT>::value>());
+check(tt::integral_constant<std::size_t,::tt::alignment_of<boost::detail::max_align>::value>());
+
+TT_TEST_END
+
+
+
+
+
+
+
+
+
Added: trunk/libs/type_traits/test/alignment_of_test_a2.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/type_traits/test/alignment_of_test_a2.cpp 2009-01-13 07:49:42 EST (Tue, 13 Jan 2009)
@@ -0,0 +1,113 @@
+
+#ifdef _MSC_VER
+#pragma pack(2)
+#endif
+
+// (C) Copyright John Maddock 2000.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+#ifdef TEST_STD
+# include <type_traits>
+#else
+# include <boost/type_traits/alignment_of.hpp>
+#endif
+
+//
+// VC++ emits an awful lot of warnings unless we define these:
+#ifdef BOOST_MSVC
+# pragma warning(disable:4244)
+//
+// What follows here is the test case for issue 1946.
+//
+#include <boost/function.hpp>
+// This kind of packing is set within MSVC 9.0 headers.
+// E.g. std::ostream has it.
+#pragma pack(push,8)
+
+// The issue is gone if Root has no data members
+struct Root { int a; };
+// The issue is gone if Root is inherited non-virtually
+struct A : virtual public Root {};
+
+#pragma pack(pop)
+//
+// This class has 8-byte alignment but is 44 bytes in size, which means
+// that elements in an array of this type will not actually be 8 byte
+// aligned. This appears to be an MSVC bug, and throws off our
+// alignment calculations: causing us to report a non-sensical 12-byte
+// alignment for this type. This is fixed by using the native __alignof
+// operator.
+//
+class issue1946 :
+ public A
+{
+public:
+ // The issue is gone if the type is not a boost::function. The signature doesn't matter.
+ typedef boost::function0< void > function_type;
+ function_type m_function;
+};
+
+#endif
+
+
+template <class T>
+struct align_calc
+{
+ char padding;
+ T instance;
+ static std::ptrdiff_t get()
+ {
+ static align_calc<T> a;
+ return reinterpret_cast<const char*>(&(a.instance)) - reinterpret_cast<const char*>(&(a.padding));
+ }
+};
+
+#define ALIGNOF(x) align_calc< x>::get()
+
+TT_TEST_BEGIN(alignment_of)
+
+#ifndef TEST_STD
+// This test is not required to work for non-boost implementations:
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<void>::value, 0);
+#endif
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<char>::value, ALIGNOF(char));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<short>::value, ALIGNOF(short));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int>::value, ALIGNOF(int));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<long>::value, ALIGNOF(long));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<float>::value, ALIGNOF(float));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<double>::value, ALIGNOF(double));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<long double>::value, ALIGNOF(long double));
+#ifdef BOOST_HAS_LONG_LONG
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of< ::boost::long_long_type>::value, ALIGNOF(::boost::long_long_type));
+#endif
+#ifdef BOOST_HAS_MS_INT64
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<__int64>::value, ALIGNOF(__int64));
+#endif
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int[4]>::value, ALIGNOF(int[4]));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int(*)(int)>::value, ALIGNOF(int(*)(int)));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<int*>::value, ALIGNOF(int*));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<VB>::value, ALIGNOF(VB));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<VD>::value, ALIGNOF(VD));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<enum_UDT>::value, ALIGNOF(enum_UDT));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<mf2>::value, ALIGNOF(mf2));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<POD_UDT>::value, ALIGNOF(POD_UDT));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<empty_UDT>::value, ALIGNOF(empty_UDT));
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<union_UDT>::value, ALIGNOF(union_UDT));
+
+#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1400)
+BOOST_CHECK_INTEGRAL_CONSTANT(::tt::alignment_of<issue1946>::value, ALIGNOF(issue1946));
+#endif
+
+TT_TEST_END
+
+
+
+
+
+
+
+