public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 18:47 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 18:47 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:07b0f0c1b3a438bfa4e6280504232a4001c888ac
commit 07b0f0c1b3a438bfa4e6280504232a4001c888ac
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (thread::_M_thread_deps): New
static implicitly-inline member function.
(std::thread template ctor): Pass it to _M_start_thread.
* src/c++11/thread.cc (thread::_M_start_thread): Name depend
parameter, force it live on entry.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 24 +++++++++++++++++-------
libstdc++-v3/src/c++11/thread.cc | 10 ++++++++--
2 files changed, 25 insertions(+), 9 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..e88c07fbd4f 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps_never_run() {
+#ifdef GTHR_ACTIVE_PROXY
+ reinterpret_cast<void (*)(void)>(&pthread_create)();
+ reinterpret_cast<void (*)(void)>(&pthread_join)();
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +158,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps_never_run);
}
#endif // _GLIBCXX_HAS_GTHREADS
diff --git a/libstdc++-v3/src/c++11/thread.cc b/libstdc++-v3/src/c++11/thread.cc
index 2d5ffaf678e..c91f7b02e1f 100644
--- a/libstdc++-v3/src/c++11/thread.cc
+++ b/libstdc++-v3/src/c++11/thread.cc
@@ -154,8 +154,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
void
- thread::_M_start_thread(_State_ptr state, void (*)())
+ thread::_M_start_thread(_State_ptr state, void (*depend)())
{
+ // Make sure it's not optimized out, not even with LTO.
+ asm ("" : : "rm" (depend));
+
if (!__gthread_active_p())
{
#if __cpp_exceptions
@@ -190,8 +193,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
void
- thread::_M_start_thread(__shared_base_type __b, void (*)())
+ thread::_M_start_thread(__shared_base_type __b, void (*depend)())
{
+ // Make sure it's not optimized out, not even with LTO.
+ asm ("" : : "rm" (depend));
+
auto ptr = __b.get();
// Create a reference cycle that will be broken in the new thread.
ptr->_M_this_ptr = std::move(__b);
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 17:36 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 17:36 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:2a01a08b7dfb4102d5f86149536e5fc238b3e53d
commit 2a01a08b7dfb4102d5f86149536e5fc238b3e53d
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (thread::_M_thread_deps): New
static inline function.
(std::thread template ctor): Pass it to _M_start_thread.
* sr/c++11/thread.cc (thread::_M_start_thread): Name depend
parameter, force it live on entry.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 51 +++++++++++++++++++++++++++++-----
libstdc++-v3/src/c++11/thread.cc | 10 +++++--
2 files changed, 52 insertions(+), 9 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..3ffd2a823a6 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,49 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps_never_run() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 0
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#elif 0
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+#elif 0
+ asm goto ("" : : : : _M_never_run);
+ if (0)
+ {
+ _M_never_run:
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#elif 0
+ bool _M_skip_always = false;
+ asm ("" : "+rm" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, false))
+ {
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#else
+ reinterpret_cast<void (*)(void)>(&pthread_create)();
+ reinterpret_cast<void (*)(void)>(&pthread_join)();
+#endif
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +185,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps_never_run);
}
#endif // _GLIBCXX_HAS_GTHREADS
diff --git a/libstdc++-v3/src/c++11/thread.cc b/libstdc++-v3/src/c++11/thread.cc
index 2d5ffaf678e..c91f7b02e1f 100644
--- a/libstdc++-v3/src/c++11/thread.cc
+++ b/libstdc++-v3/src/c++11/thread.cc
@@ -154,8 +154,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
void
- thread::_M_start_thread(_State_ptr state, void (*)())
+ thread::_M_start_thread(_State_ptr state, void (*depend)())
{
+ // Make sure it's not optimized out, not even with LTO.
+ asm ("" : : "rm" (depend));
+
if (!__gthread_active_p())
{
#if __cpp_exceptions
@@ -190,8 +193,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
void
- thread::_M_start_thread(__shared_base_type __b, void (*)())
+ thread::_M_start_thread(__shared_base_type __b, void (*depend)())
{
+ // Make sure it's not optimized out, not even with LTO.
+ asm ("" : : "rm" (depend));
+
auto ptr = __b.get();
// Create a reference cycle that will be broken in the new thread.
ptr->_M_this_ptr = std::move(__b);
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 15:05 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 15:05 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:650264d04949bed3a9b5d28d5216341f3827d7ae
commit 650264d04949bed3a9b5d28d5216341f3827d7ae
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (thread::_M_thread_deps): New
static inline function.
(std::thread template ctor): Pass it to _M_start_thread.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 51 +++++++++++++++++++++++++++++-----
1 file changed, 44 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..3ffd2a823a6 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,49 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps_never_run() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 0
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#elif 0
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+#elif 0
+ asm goto ("" : : : : _M_never_run);
+ if (0)
+ {
+ _M_never_run:
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#elif 0
+ bool _M_skip_always = false;
+ asm ("" : "+rm" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, false))
+ {
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#else
+ reinterpret_cast<void (*)(void)>(&pthread_create)();
+ reinterpret_cast<void (*)(void)>(&pthread_join)();
+#endif
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +185,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps_never_run);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 15:04 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 15:04 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:bfcd8e8222c9921482a48dc2c8f3390a3ac1275a
commit bfcd8e8222c9921482a48dc2c8f3390a3ac1275a
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (thread::_M_thread_deps): New
static inline function.
(std::thread template ctor): Pass it to _M_start_thread.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 51 +++++++++++++++++++++++++++++-----
1 file changed, 44 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..9b3b57def28 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,49 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps_never_run() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 0
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#elif 0
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+#elif 0
+ asm goto ("" : : : : _M_never_run);
+ if (0)
+ {
+ _M_never_run:
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#elif 0
+ bool _M_skip_always = false;
+ asm ("" : "+rm" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, false))
+ {
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#else
+ (reinterpret_cast<void (*)(void)>&pthread_create)();
+ (reinterpret_cast<void (*)(void)>&pthread_join)();
+#endif
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +185,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps_never_run);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 15:01 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 15:01 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:d82e731fc4e198b406bb8e8155a542caa409270d
commit d82e731fc4e198b406bb8e8155a542caa409270d
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (thread::_M_thread_deps): New
static inline function.
(std::thread template ctor): Pass it to _M_start_thread.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 48 +++++++++++++++++++++++++++++-----
1 file changed, 41 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..bac0a8ffbd8 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,46 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps_never_run() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 0
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#elif 0
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+#elif 0
+ asm goto ("" : : : : _M_never_run);
+ if (0)
+ {
+ _M_never_run:
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#else
+ bool _M_skip_always = false;
+ asm ("" : "+rm" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, false))
+ {
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#endif
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +182,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps_never_run);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 14:59 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 14:59 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:f258ef7e44aefac0f732f25dd6a6263780dc7fae
commit f258ef7e44aefac0f732f25dd6a6263780dc7fae
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (thread::_M_thread_deps): New
static inline function.
(std::thread template ctor): Pass it to _M_start_thread.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 48 +++++++++++++++++++++++++++++-----
1 file changed, 41 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..1ceb11cbed8 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,46 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps_never_run() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 0
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#elif 0
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+#elif 0
+ asm goto ("" : : : : _M_never_run);
+ if (0)
+ {
+ _M_never_run:
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#else
+ bool _M_skip_always = false;
+ asm ("" : "+X" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, false))
+ {
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#endif
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +182,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps_never_run);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 14:57 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 14:57 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:de1aa8c9603f4b7f26a8cb100a39567c9dcb17f6
commit de1aa8c9603f4b7f26a8cb100a39567c9dcb17f6
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (thread::_M_thread_deps): New
static inline function.
(std::thread template ctor): Pass it to _M_start_thread.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 48 +++++++++++++++++++++++++++++-----
1 file changed, 41 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..a4132ca86e5 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,46 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps_never_run() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 0
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#elif 0
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+#elif 1
+ asm goto ("" : : : : _M_never_run);
+ if (0)
+ {
+ _M_never_run:
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#else
+ bool _M_skip_always = false;
+ asm ("" : "+X" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, false))
+ {
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#endif
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +182,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps_never_run);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 14:45 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 14:45 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:002801e432d3ef7ecda97fa3bf896dd9d09572bb
commit 002801e432d3ef7ecda97fa3bf896dd9d09572bb
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (thread::_M_thread_deps): New
static inline function.
(std::thread template ctor): Pass it to _M_start_thread.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 48 +++++++++++++++++++++++++++++-----
1 file changed, 41 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..7d0d56150af 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,46 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps_never_run() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 0
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#elif 1
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+#elif 0
+ asm goto ("" : : : : _M_never_run);
+ if (0)
+ {
+ _M_never_run:
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#else
+ bool _M_skip_always = false;
+ asm ("" : "+X" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, false))
+ {
+ pthread_t thr;
+ pthread_create (&thr, nullptr, nullptr, nullptr);
+ pthread_join (thr, nullptr);
+ }
+#endif
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +182,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps_never_run);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 14:42 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 14:42 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:5fa7dc8d67720974cc635651822116b4e6a70c84
commit 5fa7dc8d67720974cc635651822116b4e6a70c84
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (thread::_M_thread_deps): New
static inline function.
(std::thread template ctor): Pass it to _M_start_thread.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 48 +++++++++++++++++++++++++++++-----
1 file changed, 41 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..ac13e400e1c 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,46 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps_never_run() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 0
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#elif 1
+ pthread_create (0, nullptr, nullptr, nullptr);
+ pthread_join (nullptr, nullptr);
+#elif 0
+ asm goto ("" : : : : _M_never_run);
+ if (0)
+ {
+ _M_never_run:
+ pthread_create (nullptr, nullptr, nullptr, nullptr);
+ pthread_join (nullptr, nullptr);
+ }
+#else
+ int _M_skip_always = 0;
+ asm ("" : "+X" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, 0))
+ {
+ // This never runs.
+ if (_M_skip_always > 0)
+ pthread_create (nullptr, nullptr, nullptr, nullptr);
+ else
+ pthread_join (nullptr, nullptr);
+ }
+#endif
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +182,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps_never_run);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 14:40 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 14:40 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:a35eac931d50ed9b0dd00a938ab5cb396bd671d1
commit a35eac931d50ed9b0dd00a938ab5cb396bd671d1
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (thread::_M_thread_deps): New
static inline function.
(std::thread template ctor): Pass it to _M_start_thread.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 48 +++++++++++++++++++++++++++++-----
1 file changed, 41 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..4c8e8464269 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,46 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps_never_run() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 0
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#elif 1
+ pthread_create (nullptr, nullptr, nullptr, nullptr);
+ pthread_join (nullptr, nullptr);
+#elif 0
+ asm goto ("" : : : : _M_never_run);
+ if (0)
+ {
+ _M_never_run:
+ pthread_create (nullptr, nullptr, nullptr, nullptr);
+ pthread_join (nullptr, nullptr);
+ }
+#else
+ int _M_skip_always = 0;
+ asm ("" : "+X" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, 0))
+ {
+ // This never runs.
+ if (_M_skip_always > 0)
+ pthread_create (nullptr, nullptr, nullptr, nullptr);
+ else
+ pthread_join (nullptr, nullptr);
+ }
+#endif
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +182,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps_never_run);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 13:11 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 13:11 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:6f67ec05d6e1aad9b01a634575b6a10fae5ea6bc
commit 6f67ec05d6e1aad9b01a634575b6a10fae5ea6bc
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (std::thread ctor): Add strong
reference to pthread_join.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 45 ++++++++++++++++++++++++++++------
1 file changed, 38 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..69b1c6cc5ad 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,43 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static void
+ _M_thread_deps() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 1
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#elif 0
+ asm goto ("" : : : : _M_never_run);
+ if (0)
+ {
+ _M_never_run:
+ pthread_create (nullptr, nullptr, nullptr, nullptr);
+ pthread_join (nullptr, nullptr);
+ }
+#else
+ int _M_skip_always = 0;
+ asm ("" : "+X" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, 0))
+ {
+ // This never runs.
+ if (_M_skip_always > 0)
+ pthread_create (nullptr, nullptr, nullptr, nullptr);
+ else
+ pthread_join (nullptr, nullptr);
+ }
+#endif
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +179,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ _M_thread_deps);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 12:39 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 12:39 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:4d6372bccaf7bb429ede0ece301001e724272eb0
commit 4d6372bccaf7bb429ede0ece301001e724272eb0
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (std::thread ctor): Add strong
reference to pthread_join.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 35 +++++++++++++++++++++++++++-------
1 file changed, 28 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..94aef1ae6d9 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static inline __attribute__ ((__always_inline__)) void
+ _M_thread_deps() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 1
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#else
+ bool _M_skip_always = false;
+ asm ("" : "+X" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, false))
+ {
+ pthread_create (nullptr, nullptr, nullptr, nullptr);
+ pthread_join (nullptr, nullptr);
+ }
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +167,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
+ _M_thread_deps ();
+
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ nullptr);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 12:37 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 12:37 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:05e3d9715dd710753d7c1084a893bd6ae81dfe73
commit 05e3d9715dd710753d7c1084a893bd6ae81dfe73
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (std::thread ctor): Add strong
reference to pthread_join.
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 35 +++++++++++++++++++++++++++-------
1 file changed, 28 insertions(+), 7 deletions(-)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..94aef1ae6d9 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -132,6 +132,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread() noexcept = default;
#ifdef _GLIBCXX_HAS_GTHREADS
+ private:
+ // This adds to user code that creates std:thread objects (because
+ // it is called by the template ctor below) strong references to
+ // pthread_create and pthread_join, which ensures they are both
+ // linked in even during static linking. We can't depend on
+ // gthread calls to bring them in, because those may use weak
+ // references.
+ static inline __attribute__ ((__always_inline__)) void
+ _M_thread_deps() {
+#ifdef GTHR_ACTIVE_PROXY
+#if 1
+ static auto const __attribute__ ((__used__)) _M_create = pthread_create;
+ static auto const __attribute__ ((__used__)) _M_join = pthread_join;
+#else
+ bool _M_skip_always = false;
+ asm ("" : "+X" (_M_skip_always));
+ if (__builtin_expect (_M_skip_always, false))
+ {
+ pthread_create (nullptr, nullptr, nullptr, nullptr);
+ pthread_join (nullptr, nullptr);
+ }
+#endif
+ }
+
+ public:
template<typename _Callable, typename... _Args,
typename = _Require<__not_same<_Callable>>>
explicit
@@ -142,18 +167,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"std::thread arguments must be invocable after conversion to rvalues"
);
-#ifdef GTHR_ACTIVE_PROXY
- // Create a reference to pthread_create, not just the gthr weak symbol.
- auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
-#else
- auto __depend = nullptr;
-#endif
+ _M_thread_deps ();
+
using _Wrapper = _Call_wrapper<_Callable, _Args...>;
// Create a call wrapper with DECAY_COPY(__f) as its target object
// and DECAY_COPY(__args)... as its bound argument entities.
_M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
- __depend);
+ nullptr);
}
#endif // _GLIBCXX_HAS_GTHREADS
^ permalink raw reply [flat|nested] 14+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor
@ 2023-03-03 5:23 Alexandre Oliva
0 siblings, 0 replies; 14+ messages in thread
From: Alexandre Oliva @ 2023-03-03 5:23 UTC (permalink / raw)
To: gcc-cvs, libstdc++-cvs
https://gcc.gnu.org/g:45fd40a3a15f083ea13e515e8b6ab62189736df8
commit 45fd40a3a15f083ea13e515e8b6ab62189736df8
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Mar 3 02:14:53 2023 -0300
link pthread_join from std::thread ctor
Like pthread_create, pthread_join may fail to be statically linked in
absent strong uses, so add to user code strong references to both when
std::thread objects are created.
for libstdc++-v3/ChangeLog
* include/bits/std_thread.h (std::thread ctor): Add strong
reference to pthread_join.
* testsuite/30_threads/jthread/95989.cc: Drop extraneous join
call.
Change-Id: I6c40875f7f7c2c08278f950f23e3b7163dd71c5c
TN: W127-055
Diff:
---
libstdc++-v3/include/bits/std_thread.h | 1 +
1 file changed, 1 insertion(+)
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index adbd3928ff7..a504a0b48ed 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -145,6 +145,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#ifdef GTHR_ACTIVE_PROXY
// Create a reference to pthread_create, not just the gthr weak symbol.
auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
+ static auto __attribute__((__unused__)) __depend_join = &pthread_join;
#else
auto __depend = nullptr;
#endif
^ permalink raw reply [flat|nested] 14+ messages in thread
end of thread, other threads:[~2023-03-03 18:47 UTC | newest]
Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-03-03 18:47 [gcc(refs/users/aoliva/heads/testme)] link pthread_join from std::thread ctor Alexandre Oliva
-- strict thread matches above, loose matches on Subject: below --
2023-03-03 17:36 Alexandre Oliva
2023-03-03 15:05 Alexandre Oliva
2023-03-03 15:04 Alexandre Oliva
2023-03-03 15:01 Alexandre Oliva
2023-03-03 14:59 Alexandre Oliva
2023-03-03 14:57 Alexandre Oliva
2023-03-03 14:45 Alexandre Oliva
2023-03-03 14:42 Alexandre Oliva
2023-03-03 14:40 Alexandre Oliva
2023-03-03 13:11 Alexandre Oliva
2023-03-03 12:39 Alexandre Oliva
2023-03-03 12:37 Alexandre Oliva
2023-03-03 5:23 Alexandre Oliva
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).