Re: [PATCH] Replace __bind_simple with std::thread::__make_invoker

[Jonathan Wakely]

On 13/10/16 13:20 +0100, Jonathan Wakely wrote:

On 13/10/16 14:16 +0200, Thomas Schwinge wrote:

Hi!

Build failure after trunk r241093:

  [...]/source-gcc/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc:121:12: 
error: ISO C++ forbids declaration of '_Bind_simple_helper' with no type 
[-fpermissive]
     template _Bind_simple_helper<void (thread::*)(), reference_wrapper<thread>>::__type 
__bind_simple(void (thread::*&&)(), reference_wrapper<thread>&&);
              ^~~~~~~~~~~~~~~~~~~
  [...]/source-gcc/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc:121:12: 
error: '_Bind_simple_helper' is not a template function
  [...]/source-gcc/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc:121:31: 
error: expected ';' before '<' token
     template _Bind_simple_helper<void (thread::*)(), reference_wrapper<thread>>::__type 
__bind_simple(void (thread::*&&)(), reference_wrapper<thread>&&);
                                 ^

Erk, I meant to move the removed code to the compatibility file, but
lost that part of the commit, sorry.

Fix coming up ...

Fix committed to trunk, and tested with a clean build this time.



commit 58542a85cfa34ee186542c879352a9802fec6e7d
Author: Jonathan Wakely <jwak...@redhat.com>
Date:   Thu Oct 13 13:33:07 2016 +0100

    Restore __bind_simple for compat symbols
    
    	* src/c++11/compatibility-thread-c++0x.cc (_Bind_simple)
    	(_Bind_simple_helper, __bind_simple): Restore for ABI compat symbols.

diff --git a/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc b/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc
index 922fa00..5ca2da8 100644
--- a/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc
+++ b/libstdc++-v3/src/c++11/compatibility-thread-c++0x.cc
@@ -116,6 +116,68 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
   // Replaced with inline definition in gcc-4.8.0
   __future_base::_Async_state_common::~_Async_state_common() { _M_join(); }
 
+  template<typename _Signature>
+    struct _Bind_simple;
+
+  template<typename _Callable, typename... _Args>
+    struct _Bind_simple<_Callable(_Args...)>
+    {
+      typedef typename result_of<_Callable(_Args...)>::type result_type;
+
+      template<typename _Tp, typename... _Up>
+        explicit
+        _Bind_simple(_Tp&& __f, _Up&&... __args)
+        : _M_bound(std::forward<_Tp>(__f), std::forward<_Up>(__args)...)
+        { }
+
+      _Bind_simple(const _Bind_simple&) = default;
+      _Bind_simple(_Bind_simple&&) = default;
+
+      result_type
+      operator()()
+      {
+        typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
+        return _M_invoke(_Indices());
+      }
+
+    private:
+      template<std::size_t... _Indices>
+        typename result_of<_Callable(_Args...)>::type
+        _M_invoke(_Index_tuple<_Indices...>)
+        {
+         // std::bind always forwards bound arguments as lvalues,
+         // but this type can call functions which only accept rvalues.
+          return std::forward<_Callable>(std::get<0>(_M_bound))(
+              std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
+        }
+
+      std::tuple<_Callable, _Args...> _M_bound;
+    };
+
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_simple_helper
+    {
+      typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
+        __maybe_type;
+      typedef typename __maybe_type::type __func_type;
+      typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
+               __type;
+    };
+
+  // Simplified version of std::bind for internal use, without support for
+  // unbound arguments, placeholders or nested bind expressions.
+  template<typename _Callable, typename... _Args>
+    typename _Bind_simple_helper<_Callable, _Args...>::__type
+    __bind_simple(_Callable&& __callable, _Args&&... __args)
+    {
+      typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
+      typedef typename __helper_type::__maybe_type __maybe_type;
+      typedef typename __helper_type::__type __result_type;
+      return __result_type(
+          __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
+          std::forward<_Args>(__args)...);
+    }
+
   // Explicit instantiation due to -fno-implicit-instantiation.
   template void call_once(once_flag&, void (thread::*&&)(), reference_wrapper<thread>&&);
   template _Bind_simple_helper<void (thread::*)(), reference_wrapper<thread>>::__type __bind_simple(void (thread::*&&)(), reference_wrapper<thread>&&);