merging intrusive from develop

doc/intrusive.qbk

@@ -3870,6 +3870,13 @@ to be inserted in intrusive containers are allocated using `std::vector` or `std
 
 [section:release_notes Release Notes]
 
+[section:release_notes_boost_1_67_00 Boost 1.67 Release]
+
+*  Fixed bugs:
+   *  [@https://github.com/boostorg/intrusive/issues/29 GitHub Issues #29: ['Uninitialized variable warning pointer_plus_bits.hpp]]
+
+[endsect]
+
 [section:release_notes_boost_1_65_00 Boost 1.65 Release]
 
 *  Fixed bugs:

include/boost/intrusive/detail/config_begin.hpp

@@ -17,33 +17,20 @@
 #ifdef BOOST_MSVC
 
    #pragma warning (push)
-   //
+   #pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier"
-   //'function' : resolved overload was found by argument-dependent lookup
+   #pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2"
-   //A function found by argument-dependent lookup (Koenig lookup) was eventually
+   #pragma warning (disable : 4675) // "method" should be declared "static" and have exactly one parameter
-   //chosen by overload resolution.
+   #pragma warning (disable : 4996) // "function": was declared deprecated
-   //
+   #pragma warning (disable : 4503) // "identifier" : decorated name length exceeded, name was truncated
-   //In Visual C++ .NET and earlier compilers, a different function would have
-   //been called. To pick the original function, use an explicitly qualified name.
-   //
-
-   //warning C4275: non dll-interface class 'x' used as base for
-   //dll-interface class 'Y'
-   #pragma warning (disable : 4275)
-   //warning C4251: 'x' : class 'y' needs to have dll-interface to
-   //be used by clients of class 'z'
-   #pragma warning (disable : 4251)
-   #pragma warning (disable : 4675)
-   #pragma warning (disable : 4996)
-   #pragma warning (disable : 4503)
    #pragma warning (disable : 4284) // odd return type for operator->
    #pragma warning (disable : 4244) // possible loss of data
    #pragma warning (disable : 4521) ////Disable "multiple copy constructors specified"
    #pragma warning (disable : 4127) //conditional expression is constant
-   #pragma warning (disable : 4146)
+   #pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
    #pragma warning (disable : 4267) //conversion from 'X' to 'Y', possible loss of data
    #pragma warning (disable : 4541) //'typeid' used on polymorphic type 'boost::exception' with /GR-
    #pragma warning (disable : 4512) //'typeid' used on polymorphic type 'boost::exception' with /GR-
-   #pragma warning (disable : 4522)
+   #pragma warning (disable : 4522) // "class" : multiple assignment operators specified
    #pragma warning (disable : 4706) //assignment within conditional expression
    #pragma warning (disable : 4710) // function not inlined
    #pragma warning (disable : 4714) // "function": marked as __forceinline not inlined

include/boost/intrusive/hashtable.hpp

@@ -115,26 +115,89 @@ bool priv_algo_is_permutation(ForwardIterator1 first1, ForwardIterator1 last1, F
 template<int Dummy = 0>
 struct prime_list_holder
 {
+   private:
+
+   template <class SizeType> // sizeof(SizeType) < sizeof(std::size_t)
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType truncate_size_type(std::size_t n, detail::true_)
+   {
+      return n < std::size_t(SizeType(-1)) ? static_cast<SizeType>(n) : SizeType(-1);
+   }
+
+   template <class SizeType> // sizeof(SizeType) == sizeof(std::size_t)
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType truncate_size_type(std::size_t n, detail::false_)
+   {
+      return static_cast<SizeType>(n);
+   }
+
+   template <class SizeType>  //sizeof(SizeType) > sizeof(std::size_t)
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_upper_bucket_count_dispatch(SizeType n, detail::true_)
+   {
+      std::size_t const c = n > std::size_t(-1)
+                            ? std::size_t(-1)
+                            : suggested_upper_bucket_count_impl(static_cast<std::size_t>(n));
+      return static_cast<SizeType>(c);
+   }
+
+   template <class SizeType>  //sizeof(SizeType) > sizeof(std::size_t)
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_lower_bucket_count_dispatch(SizeType n, detail::true_)
+   {
+      std::size_t const c = n > std::size_t(-1)
+                            ? std::size_t(-1)
+                            : suggested_lower_bucket_count_impl(static_cast<std::size_t>(n));
+      return static_cast<SizeType>(c);
+   }
+
+   template <class SizeType>
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_upper_bucket_count_dispatch(SizeType n, detail::false_)
+   {
+      std::size_t const c = suggested_upper_bucket_count_impl(static_cast<std::size_t>(n));
+      return truncate_size_type<SizeType>(c, detail::bool_<(sizeof(SizeType) < sizeof(std::size_t))>());
+
+   }
+
+   template <class SizeType>
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_lower_bucket_count_dispatch(SizeType n, detail::false_)
+   {
+      std::size_t const c = suggested_lower_bucket_count_impl(static_cast<std::size_t>(n));
+      return truncate_size_type<SizeType>(c, detail::bool_<(sizeof(SizeType) < sizeof(std::size_t))>());
+   }
+
    static const std::size_t prime_list[];
    static const std::size_t prime_list_size;
 
-   static std::size_t suggested_upper_bucket_count(std::size_t n)
+   static std::size_t suggested_lower_bucket_count_impl(std::size_t n)
    {
       const std::size_t *primes     = &prime_list_holder<0>::prime_list[0];
       const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
       std::size_t const* bound = std::lower_bound(primes, primes_end, n);
-      bound -= (bound == primes_end);
+      //Tables have upper SIZE_MAX, so we must always found an entry
+      BOOST_INTRUSIVE_INVARIANT_ASSERT(bound != primes_end);
+      bound -= std::size_t(bound != primes);
       return *bound;
    }
 
-   static std::size_t suggested_lower_bucket_count(std::size_t n)
+   static std::size_t suggested_upper_bucket_count_impl(std::size_t n)
    {
       const std::size_t *primes     = &prime_list_holder<0>::prime_list[0];
       const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
       std::size_t const* bound = std::upper_bound(primes, primes_end, n);
-      bound -= (bound != primes);
+      bound -= std::size_t(bound == primes_end);
       return *bound;
    }
+
+   public:
+
+   template <class SizeType>
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_upper_bucket_count(SizeType n)
+   {
+      return (suggested_upper_bucket_count_dispatch)(n, detail::bool_<(sizeof(SizeType) > sizeof(std::size_t))>());
+   }
+
+   template <class SizeType>
+   static BOOST_INTRUSIVE_FORCEINLINE SizeType suggested_lower_bucket_count(SizeType n)
+   {
+      return (suggested_lower_bucket_count_dispatch)(n, detail::bool_<(sizeof(SizeType) > sizeof(std::size_t))>());
+   }
 };
 
 #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
@@ -184,9 +247,9 @@ const std::size_t prime_list_holder<Dummy>::prime_list[] = {
    BOOST_INTRUSIVE_PRIME_C(432345564227567621),    BOOST_INTRUSIVE_PRIME_C(864691128455135207),
    BOOST_INTRUSIVE_PRIME_C(1729382256910270481),   BOOST_INTRUSIVE_PRIME_C(3458764513820540933),
    BOOST_INTRUSIVE_PRIME_C(6917529027641081903),   BOOST_INTRUSIVE_PRIME_C(13835058055282163729),
-   BOOST_INTRUSIVE_PRIME_C(18446744073709551557)
+   BOOST_INTRUSIVE_PRIME_C(18446744073709551557),  BOOST_INTRUSIVE_PRIME_C(18446744073709551615)   //Upper limit, just in case
 #else
-   BOOST_INTRUSIVE_PRIME_C(4294967291)
+   BOOST_INTRUSIVE_PRIME_C(4294967291),            BOOST_INTRUSIVE_PRIME_C(4294967295)             //Upper limit, just in case
 #endif
    };
 
@@ -1476,16 +1539,12 @@ struct hashdata_internal
 
    static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_upper_bucket_count(size_type n)
    {
-      std::size_t c = prime_list_holder<0>::suggested_upper_bucket_count
+      return prime_list_holder<0>::suggested_upper_bucket_count(n);
-         (sizeof(size_type) > sizeof(std::size_t) && n > std::size_t(-1) ? std::size_t(-1) : static_cast<std::size_t>(n));
-      return sizeof(size_type) < sizeof(std::size_t) && c > size_type(-1) ? size_type(-1) : static_cast<size_type>(c);
    }
 
    static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_lower_bucket_count(size_type n)
    {
-      std::size_t c = prime_list_holder<0>::suggested_lower_bucket_count
+      return prime_list_holder<0>::suggested_lower_bucket_count(n);
-         (sizeof(size_type) > sizeof(std::size_t) && n > std::size_t(-1) ? std::size_t(-1) : static_cast<std::size_t>(n));
-      return sizeof(size_type) < sizeof(std::size_t) && c > size_type(-1) ? size_type(-1) : static_cast<size_type>(c);
    }
 
    const_local_iterator cbegin(size_type n) const
@@ -1497,6 +1556,7 @@ struct hashdata_internal
 
    using internal_type::end;
    using internal_type::cend;
+
    local_iterator end(size_type n)
    {  return local_iterator(this->priv_bucket_pointer()[n].end(), this->priv_value_traits_ptr());  }
 

include/boost/intrusive/pointer_plus_bits.hpp

@@ -22,6 +22,17 @@
 #  pragma once
 #endif
 
+
+//GCC reports uninitialized values when an uninitialized pointer plus bits type
+//is asigned some bits or some pointer value, but that's ok, because we don't want
+//to default initialize parts that are not being updated.
+#if defined(BOOST_GCC)
+#  if (BOOST_GCC >= 40600)
+#     pragma GCC diagnostic push
+#     pragma GCC diagnostic ignored "-Wuninitialized"
+#  endif
+#endif
+
 namespace boost {
 namespace intrusive {
 
@@ -89,6 +100,10 @@ struct pointer_plus_bits<T*, NumBits>
 } //namespace intrusive
 } //namespace boost
 
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#  pragma GCC diagnostic pop
+#endif
+
 #include <boost/intrusive/detail/config_end.hpp>
 
 #endif //BOOST_INTRUSIVE_POINTER_PLUS_BITS_HPP