[oe-commits] [openembedded-core] 24/41: glibc: fix pthread_cond_broadcast issue (arm)
git at git.openembedded.org
git at git.openembedded.org
Tue Aug 29 14:13:45 UTC 2017
This is an automated email from the git hooks/post-receive script.
rpurdie pushed a commit to branch morty-next
in repository openembedded-core.
commit 6dc1f1c3cc871d00ecd59d5aeeef86b7e6965750
Author: Catalin Enache <catalin.enache at windriver.com>
AuthorDate: Fri Jul 7 19:43:34 2017 +0300
glibc: fix pthread_cond_broadcast issue (arm)
pthread_mutex functions such as pthread_cond_wait(), pthread_mutex_unlock() return
errors after PTHREAD_PRIO_INHERIT is enabled
Reference:
https://sourceware.org/bugzilla/show_bug.cgi?id=18463
Upstream patches:
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=f0e3925bf3b8df6940c3346db17e42615979d458
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=13cb8f76da9d9420330796f469dbf10643ba5b12
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=23b5cae1af04f2d912910fdaf73cb482265798c1
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=ed19993b5b0d05d62cc883571519a67dae481a14
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=2e4cf778972573221e9b87fd992844ea9b67b9bf
https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=abff18c0c6055ca5d1cd46923fd1205c057139a5
This issue is Morty specific (glibc 2.24).
The issue is no longer present in glibc 2.25 (master branch).
Signed-off-by: Catalin Enache <catalin.enache at windriver.com>
Signed-off-by: Armin Kuster <akuster808 at gmail.com>
---
.../glibc/0001-Add-atomic_exchange_relaxed.patch | 58 +
...operations-required-by-the-new-condition-.patch | 124 +
...d-pretty-printers-for-the-NPTL-lock-types.patch | 3197 +++++++++
...-implementation-that-provides-stronger-or.patch | 7171 ++++++++++++++++++++
.../glibc/0005-Remove-__ASSUME_REQUEUE_PI.patch | 149 +
.../glibc/0006-Fix-atomic_fetch_xor_release.patch | 81 +
meta/recipes-core/glibc/glibc_2.24.bb | 6 +
7 files changed, 10786 insertions(+)
diff --git a/meta/recipes-core/glibc/glibc/0001-Add-atomic_exchange_relaxed.patch b/meta/recipes-core/glibc/glibc/0001-Add-atomic_exchange_relaxed.patch
new file mode 100644
index 0000000..a33a135
--- /dev/null
+++ b/meta/recipes-core/glibc/glibc/0001-Add-atomic_exchange_relaxed.patch
@@ -0,0 +1,58 @@
+From ce74a620bf9e1a40b7ba06d35160e20633a4d8bb Mon Sep 17 00:00:00 2001
+From: Catalin Enache <catalin.enache at windriver.com>
+Date: Fri, 7 Jul 2017 13:11:16 +0300
+Subject: [PATCH 1/6] Add atomic_exchange_relaxed.
+
+* include/atomic.h (atomic_exchange_relaxed): New
+
+Upstream-Status: Backport
+
+Author: Torvald Riegel <triegel at redhat.com>
+Signed-off-by: Catalin Enache <catalin.enache at windriver.com>
+---
+ ChangeLog | 4 ++++
+ include/atomic.h | 9 +++++++++
+ 2 files changed, 13 insertions(+)
+
+diff --git a/ChangeLog b/ChangeLog
+index 0fbda90..cb87279 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,7 @@
++2016-08-05 Torvald Riegel <triegel at redhat.com>
++
++ * include/atomic.h (atomic_exchange_relaxed): New.
++
+ 2016-01-28 Carlos O'Donell <carlos at redhat.com>
+ Alexey Makhalov <amakhalov at vmware.com>
+ Florian Weimer <fweimer at redhat.com>
+diff --git a/include/atomic.h b/include/atomic.h
+index ad3db25..129ee24 100644
+--- a/include/atomic.h
++++ b/include/atomic.h
+@@ -588,6 +588,9 @@ void __atomic_link_error (void);
+ __atomic_compare_exchange_n ((mem), (expected), (desired), 1, \
+ __ATOMIC_RELEASE, __ATOMIC_RELAXED); })
+
++# define atomic_exchange_relaxed(mem, desired) \
++ ({ __atomic_check_size((mem)); \
++ __atomic_exchange_n ((mem), (desired), __ATOMIC_RELAXED); })
+ # define atomic_exchange_acquire(mem, desired) \
+ ({ __atomic_check_size((mem)); \
+ __atomic_exchange_n ((mem), (desired), __ATOMIC_ACQUIRE); })
+@@ -684,6 +687,12 @@ void __atomic_link_error (void);
+ *(expected) == __atg103_expected; })
+ # endif
+
++/* XXX Fall back to acquire MO because archs do not define a weaker
++ atomic_exchange. */
++# ifndef atomic_exchange_relaxed
++# define atomic_exchange_relaxed(mem, val) \
++ atomic_exchange_acq ((mem), (val))
++# endif
+ # ifndef atomic_exchange_acquire
+ # define atomic_exchange_acquire(mem, val) \
+ atomic_exchange_acq ((mem), (val))
+--
+2.10.2
+
diff --git a/meta/recipes-core/glibc/glibc/0002-Add-atomic-operations-required-by-the-new-condition-.patch b/meta/recipes-core/glibc/glibc/0002-Add-atomic-operations-required-by-the-new-condition-.patch
new file mode 100644
index 0000000..c4747fa
--- /dev/null
+++ b/meta/recipes-core/glibc/glibc/0002-Add-atomic-operations-required-by-the-new-condition-.patch
@@ -0,0 +1,124 @@
+From b85e30e655027132c4326d2fdde010c517165aaf Mon Sep 17 00:00:00 2001
+From: Catalin Enache <catalin.enache at windriver.com>
+Date: Fri, 30 Jun 2017 14:27:34 +0300
+Subject: [PATCH 2/6] Add atomic operations required by the new condition
+ variable.
+
+ * include/atomic.h (atomic_fetch_and_relaxed,
+ atomic_fetch_and_release, atomic_fetch_or_release,
+ atomic_fetch_xor_release): New.
+
+Upstream-Status: Backport
+
+Author: Torvald Riegel <triegel at redhat.com>
+Signed-off-by: Catalin Enache <catalin.enache at windriver.com>
+---
+ ChangeLog | 6 ++++++
+ include/atomic.h | 47 +++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 53 insertions(+)
+
+diff --git a/ChangeLog b/ChangeLog
+index cb87279..96b6da2 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,9 @@
++2016-08-09 Torvald Riegel <triegel at redhat.com>
++
++ * include/atomic.h (atomic_fetch_and_relaxed,
++ atomic_fetch_and_release, atomic_fetch_or_release,
++ atomic_fetch_xor_release): New.
++
+ 2016-08-05 Torvald Riegel <triegel at redhat.com>
+
+ * include/atomic.h (atomic_exchange_relaxed): New.
+diff --git a/include/atomic.h b/include/atomic.h
+index 129ee24..5a8e7e7 100644
+--- a/include/atomic.h
++++ b/include/atomic.h
+@@ -611,9 +611,15 @@ void __atomic_link_error (void);
+ ({ __atomic_check_size((mem)); \
+ __atomic_fetch_add ((mem), (operand), __ATOMIC_ACQ_REL); })
+
++# define atomic_fetch_and_relaxed(mem, operand) \
++ ({ __atomic_check_size((mem)); \
++ __atomic_fetch_and ((mem), (operand), __ATOMIC_RELAXED); })
+ # define atomic_fetch_and_acquire(mem, operand) \
+ ({ __atomic_check_size((mem)); \
+ __atomic_fetch_and ((mem), (operand), __ATOMIC_ACQUIRE); })
++# define atomic_fetch_and_release(mem, operand) \
++ ({ __atomic_check_size((mem)); \
++ __atomic_fetch_and ((mem), (operand), __ATOMIC_RELEASE); })
+
+ # define atomic_fetch_or_relaxed(mem, operand) \
+ ({ __atomic_check_size((mem)); \
+@@ -621,6 +627,13 @@ void __atomic_link_error (void);
+ # define atomic_fetch_or_acquire(mem, operand) \
+ ({ __atomic_check_size((mem)); \
+ __atomic_fetch_or ((mem), (operand), __ATOMIC_ACQUIRE); })
++# define atomic_fetch_or_release(mem, operand) \
++ ({ __atomic_check_size((mem)); \
++ __atomic_fetch_or ((mem), (operand), __ATOMIC_RELEASE); })
++
++# define atomic_fetch_xor_release(mem, operand) \
++ ({ __atomic_check_size((mem)); \
++ __atomic_fetch_xor ((mem), (operand), __ATOMIC_RELEASE); })
+
+ #else /* !USE_ATOMIC_COMPILER_BUILTINS */
+
+@@ -724,12 +737,24 @@ void __atomic_link_error (void);
+ atomic_exchange_and_add_acq ((mem), (operand)); })
+ # endif
+
++/* XXX Fall back to acquire MO because archs do not define a weaker
++ atomic_and_val. */
++# ifndef atomic_fetch_and_relaxed
++# define atomic_fetch_and_relaxed(mem, operand) \
++ atomic_fetch_and_acquire ((mem), (operand))
++# endif
+ /* XXX The default for atomic_and_val has acquire semantics, but this is not
+ documented. */
+ # ifndef atomic_fetch_and_acquire
+ # define atomic_fetch_and_acquire(mem, operand) \
+ atomic_and_val ((mem), (operand))
+ # endif
++# ifndef atomic_fetch_and_release
++/* XXX This unnecessarily has acquire MO. */
++# define atomic_fetch_and_release(mem, operand) \
++ ({ atomic_thread_fence_release (); \
++ atomic_and_val ((mem), (operand)); })
++# endif
+
+ /* XXX The default for atomic_or_val has acquire semantics, but this is not
+ documented. */
+@@ -743,6 +768,28 @@ void __atomic_link_error (void);
+ # define atomic_fetch_or_relaxed(mem, operand) \
+ atomic_fetch_or_acquire ((mem), (operand))
+ # endif
++/* XXX Contains an unnecessary acquire MO because archs do not define a weaker
++ atomic_or_val. */
++# ifndef atomic_fetch_or_release
++# define atomic_fetch_or_release(mem, operand) \
++ ({ atomic_thread_fence_release (); \
++ atomic_fetch_or_acquire ((mem), (operand)); })
++# endif
++
++# ifndef atomic_fetch_xor_release
++# define atomic_fetch_xor_release(mem, operand) \
++ ({ __typeof (*(mem)) __atg104_old; \
++ __typeof (mem) __atg104_memp = (mem); \
++ __typeof (*(mem)) __atg104_op = (operand); \
++ \
++ do \
++ __atg104_old = (*__atg104_memp); \
++ while (__builtin_expect \
++ (atomic_compare_and_exchange_bool_rel ( \
++ __atg104_memp, __atg104_old ^ __atg104_op, __atg104_old), 0));\
++ \
++ __atg104_old; })
++#endif
+
+ #endif /* !USE_ATOMIC_COMPILER_BUILTINS */
+
+--
+2.10.2
+
diff --git a/meta/recipes-core/glibc/glibc/0003-Add-pretty-printers-for-the-NPTL-lock-types.patch b/meta/recipes-core/glibc/glibc/0003-Add-pretty-printers-for-the-NPTL-lock-types.patch
new file mode 100644
index 0000000..9eb635d
--- /dev/null
+++ b/meta/recipes-core/glibc/glibc/0003-Add-pretty-printers-for-the-NPTL-lock-types.patch
@@ -0,0 +1,3197 @@
+From 246fee86fc90c57738ee282a061039f82832f4ea Mon Sep 17 00:00:00 2001
+From: Catalin Enache <catalin.enache at windriver.com>
+Date: Fri, 30 Jun 2017 13:42:04 +0300
+Subject: [PATCH 3/6] Add pretty printers for the NPTL lock types
+
+This patch adds pretty printers for the following NPTL types:
+
+- pthread_mutex_t
+- pthread_mutexattr_t
+- pthread_cond_t
+- pthread_condattr_t
+- pthread_rwlock_t
+- pthread_rwlockattr_t
+
+To load the pretty printers into your gdb session, do the following:
+
+python
+import sys
+sys.path.insert(0, '/path/to/glibc/build/nptl/pretty-printers')
+end
+
+source /path/to/glibc/source/pretty-printers/nptl-printers.py
+
+You can check which printers are registered and enabled by issuing the
+'info pretty-printer' gdb command. Printers should trigger automatically when
+trying to print a variable of one of the types mentioned above.
+
+The printers are architecture-independent, and were tested on an AMD64 running
+Ubuntu 14.04 and an x86 VM running Fedora 24.
+
+In order to work, the printers need to know the values of various flags that
+are scattered throughout pthread.h and pthreadP.h as enums and #defines. Since
+replicating these constants in the printers file itself would create a
+maintenance burden, I wrote a script called gen-py-const.awk that Makerules uses
+to extract the constants. This script is pretty much the same as gen-as-const.awk,
+except it doesn't cast the constant values to 'long' and is thorougly documented.
+The constants need only to be enumerated in a .pysym file, which is then referenced
+by a Make variable called gen-py-const-headers.
+
+As for the install directory, I discussed this with Mike Frysinger and Siddhesh
+Poyarekar, and we agreed that it can be handled in a separate patch, and shouldn't
+block merging of this one.
+
+In addition, I've written a series of test cases for the pretty printers.
+Each lock type (mutex, condvar and rwlock) has two test programs, one for itself
+and other for its related 'attributes' object. Each test program in turn has a
+PExpect-based Python script that drives gdb and compares its output to the
+expected printer's. The tests run on the glibc host, which is assumed to have
+both gdb and PExpect; if either is absent the tests will fail with code 77
+(UNSUPPORTED). For cross-testing you should use cross-test-ssh.sh as test-wrapper.
+I've tested the printers on both native builds and a cross build using a Beaglebone
+Black running Debian, with the build system's filesystem shared with the board
+through NFS.
+
+Finally, I've written a README that explains all this and more.
+
+ * INSTALL: Regenerated.
+ * Makeconfig: Add comments and whitespace to make the control flow
+ clearer.
+ (+link-printers-tests, +link-pie-printers-tests, CFLAGS-printers-tests,
+ installed-rtld-LDFLAGS, built-rtld-LDFLAGS, link-libc-rpath,
+ link-libc-tests-after-rpath-link, link-libc-printers-tests): New.
+ (rtld-LDFLAGS, rtld-tests-LDFLAGS, link-libc-tests-rpath-link,
+ link-libc-tests): Use the new variables as required.
+ * Makerules ($(py-const)): New rule.
+ generated: Add $(py-const).
+ * README.pretty-printers: New file.
+ * Rules (tests-printers-programs, tests-printers-out, py-env): New.
+ (others): Depend on $(py-const).
+ (tests): Depend on $(tests-printers-programs) or $(tests-printers-out),
+ as required. Pass $(tests-printers) to merge-test-results.sh.
+ * manual/install.texi: Add requirements for testing the pretty printers.
+ * nptl/Makefile (gen-py-const-headers, pretty-printers, tests-printers,
+ CFLAGS-test-mutexattr-printers.c CFLAGS-test-mutex-printers.c,
+ CFLAGS-test-condattr-printers.c, CFLAGS-test-cond-printers.c,
+ CFLAGS-test-rwlockattr-printers.c CFLAGS-test-rwlock-printers.c,
+ tests-printers-libs): Define.
+ * nptl/nptl-printers.py: New file.
+ * nptl/nptl_lock_constants.pysym: Likewise.
+ * nptl/test-cond-printers.c: Likewise.
+ * nptl/test-cond-printers.py: Likewise.
+ * nptl/test-condattr-printers.c: Likewise.
+ * nptl/test-condattr-printers.py: Likewise.
+ * nptl/test-mutex-printers.c: Likewise.
+ * nptl/test-mutex-printers.py: Likewise.
+ * nptl/test-mutexattr-printers.c: Likewise.
+ * nptl/test-mutexattr-printers.py: Likewise.
+ * nptl/test-rwlock-printers.c: Likewise.
+ * nptl/test-rwlock-printers.py: Likewise.
+ * nptl/test-rwlockattr-printers.c: Likewise.
+ * nptl/test-rwlockattr-printers.py: Likewise.
+ * scripts/gen-py-const.awk: Likewise.
+ * scripts/test_printers_common.py: Likewise.
+ * scripts/test_printers_exceptions.py: Likewise.
+
+Upstream-Status: Backport
+
+Author: Martin Galvan <martin.galvan at tallertechnologies.com>
+Signed-off-by: Catalin Enache <catalin.enache at windriver.com>
+---
+ ChangeLog | 45 +++
+ INSTALL | 27 ++
+ Makeconfig | 76 ++++-
+ Makerules | 46 +++
+ NEWS | 6 +
+ README.pretty-printers | 169 ++++++++++
+ Rules | 44 ++-
+ manual/install.texi | 30 ++
+ nptl/Makefile | 18 +
+ nptl/nptl-printers.py | 633 ++++++++++++++++++++++++++++++++++++
+ nptl/nptl_lock_constants.pysym | 75 +++++
+ nptl/test-cond-printers.c | 57 ++++
+ nptl/test-cond-printers.py | 50 +++
+ nptl/test-condattr-printers.c | 94 ++++++
+ nptl/test-condattr-printers.py | 71 ++++
+ nptl/test-mutex-printers.c | 151 +++++++++
+ nptl/test-mutex-printers.py | 97 ++++++
+ nptl/test-mutexattr-printers.c | 144 ++++++++
+ nptl/test-mutexattr-printers.py | 101 ++++++
+ nptl/test-rwlock-printers.c | 78 +++++
+ nptl/test-rwlock-printers.py | 64 ++++
+ nptl/test-rwlockattr-printers.c | 98 ++++++
+ nptl/test-rwlockattr-printers.py | 73 +++++
+ scripts/gen-py-const.awk | 118 +++++++
+ scripts/test_printers_common.py | 364 +++++++++++++++++++++
+ scripts/test_printers_exceptions.py | 61 ++++
+ 26 files changed, 2770 insertions(+), 20 deletions(-)
+ create mode 100644 README.pretty-printers
+ create mode 100644 nptl/nptl-printers.py
+ create mode 100644 nptl/nptl_lock_constants.pysym
+ create mode 100644 nptl/test-cond-printers.c
+ create mode 100644 nptl/test-cond-printers.py
+ create mode 100644 nptl/test-condattr-printers.c
+ create mode 100644 nptl/test-condattr-printers.py
+ create mode 100644 nptl/test-mutex-printers.c
+ create mode 100644 nptl/test-mutex-printers.py
+ create mode 100644 nptl/test-mutexattr-printers.c
+ create mode 100644 nptl/test-mutexattr-printers.py
+ create mode 100644 nptl/test-rwlock-printers.c
+ create mode 100644 nptl/test-rwlock-printers.py
+ create mode 100644 nptl/test-rwlockattr-printers.c
+ create mode 100644 nptl/test-rwlockattr-printers.py
+ create mode 100644 scripts/gen-py-const.awk
+ create mode 100644 scripts/test_printers_common.py
+ create mode 100644 scripts/test_printers_exceptions.py
+
+diff --git a/ChangeLog b/ChangeLog
+index 96b6da2..8036c1e 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,48 @@
++2016-12-08 Martin Galvan <martin.galvan at tallertechnologies.com>
++
++ * INSTALL: Regenerated.
++ * Makeconfig: Add comments and whitespace to make the control flow
++ clearer.
++ (+link-printers-tests, +link-pie-printers-tests,
++ CFLAGS-printers-tests, installed-rtld-LDFLAGS,
++ built-rtld-LDFLAGS, link-libc-rpath,
++ link-libc-tests-after-rpath-link,
++ link-libc-printers-tests): New.
++ (rtld-LDFLAGS, rtld-tests-LDFLAGS, link-libc-tests-rpath-link,
++ link-libc-tests): Use the new variables as required.
++ * Makerules ($(py-const)): New rule.
++ generated: Add $(py-const).
++ * README.pretty-printers: New file.
++ * Rules (tests-printers-programs, tests-printers-out, py-env): New.
++ (others): Depend on $(py-const).
++ (tests): Depend on $(tests-printers-programs) or
++ $(tests-printers-out),
++ as required. Pass $(tests-printers) to merge-test-results.sh.
++ * manual/install.texi: Add requirements for testing the pretty
++ printers.
++ * nptl/Makefile (gen-py-const-headers, pretty-printers,
++ tests-printers, CFLAGS-test-mutexattr-printers.c
++ CFLAGS-test-mutex-printers.c, CFLAGS-test-condattr-printers.c,
++ CFLAGS-test-cond-printers.c, CFLAGS-test-rwlockattr-printers.c
++ CFLAGS-test-rwlock-printers.c, tests-printers-libs): Define.
++ * nptl/nptl-printers.py: New file.
++ * nptl/nptl_lock_constants.pysym: Likewise.
++ * nptl/test-cond-printers.c: Likewise.
++ * nptl/test-cond-printers.py: Likewise.
++ * nptl/test-condattr-printers.c: Likewise.
++ * nptl/test-condattr-printers.py: Likewise.
++ * nptl/test-mutex-printers.c: Likewise.
++ * nptl/test-mutex-printers.py: Likewise.
++ * nptl/test-mutexattr-printers.c: Likewise.
++ * nptl/test-mutexattr-printers.py: Likewise.
++ * nptl/test-rwlock-printers.c: Likewise.
++ * nptl/test-rwlock-printers.py: Likewise.
++ * nptl/test-rwlockattr-printers.c: Likewise.
++ * nptl/test-rwlockattr-printers.py: Likewise.
++ * scripts/gen-py-const.awk: Likewise.
++ * scripts/test_printers_common.py: Likewise.
++ * scripts/test_printers_exceptions.py: Likewise.
++
+ 2016-08-09 Torvald Riegel <triegel at redhat.com>
+
+ * include/atomic.h (atomic_fetch_and_relaxed,
+diff --git a/INSTALL b/INSTALL
+index ec3445f..dd62c86 100644
+--- a/INSTALL
++++ b/INSTALL
+@@ -224,6 +224,33 @@ You can specify 'stop-on-test-failure=y' when running 'make check' to
+ make the test run stop and exit with an error status immediately when a
+ failure occurs.
+
++ The GNU C Library pretty printers come with their own set of scripts
++for testing, which run together with the rest of the testsuite through
++'make check'. These scripts require the following tools to run
++successfully:
++
++ * Python 2.7.6/3.4.3 or later
++
++ Python is required for running the printers' test scripts.
++
++ * PExpect 4.0
++
++ The printer tests drive GDB through test programs and compare its
++ output to the printers'. PExpect is used to capture the output of
++ GDB, and should be compatible with the Python version in your
++ system.
++
++ * GDB 7.8 or later with support for Python 2.7.6/3.4.3 or later
++
++ GDB itself needs to be configured with Python support in order to
++ use the pretty printers. Notice that your system having Python
++ available doesn't imply that GDB supports it, nor that your
++ system's Python and GDB's have the same version.
++
++If these tools are absent, the printer tests will report themselves as
++'UNSUPPORTED'. Notice that some of the printer tests require the GNU C
++Library to be compiled with debugging symbols.
++
+ To format the 'GNU C Library Reference Manual' for printing, type
+ 'make dvi'. You need a working TeX installation to do this. The
+ distribution builds the on-line formatted version of the manual, as Info
+diff --git a/Makeconfig b/Makeconfig
+index 03fd89c..2d92d94 100644
+--- a/Makeconfig
++++ b/Makeconfig
+@@ -416,6 +416,11 @@ $(+link-pie-before-libc) $(rtld-tests-LDFLAGS) $(link-libc-tests) \
+ $(+link-pie-after-libc)
+ $(call after-link,$@)
+ endef
++define +link-pie-printers-tests
++$(+link-pie-before-libc) $(built-rtld-LDFLAGS) $(link-libc-printers-tests) \
++ $(+link-pie-after-libc)
++$(call after-link,$@)
++endef
+ endif
+ # Command for statically linking programs with the C library.
+ ifndef +link-static
+@@ -445,7 +450,8 @@ ifeq (yes,$(build-pie-default))
+ no-pie-ldflag = -no-pie
+ +link = $(+link-pie)
+ +link-tests = $(+link-pie-tests)
+-else
+++link-printers-tests = $(+link-pie-printers-tests)
++else # not build-pie-default
+ +link-before-libc = $(CC) -nostdlib -nostartfiles -o $@ \
+ $(sysdep-LDFLAGS) $(LDFLAGS) $(LDFLAGS-$(@F)) \
+ $(combreloc-LDFLAGS) $(relro-LDFLAGS) $(hashstyle-LDFLAGS) \
+@@ -466,51 +472,87 @@ $(+link-before-libc) $(rtld-tests-LDFLAGS) $(link-libc-tests) \
+ $(+link-after-libc)
+ $(call after-link,$@)
+ endef
+-endif
+-else
++define +link-printers-tests
++$(+link-before-libc) $(built-rtld-LDFLAGS) $(link-libc-printers-tests) \
++ $(+link-after-libc)
++$(call after-link,$@)
++endef
++endif # build-pie-default
++else # build-static
+ +link = $(+link-static)
+ +link-tests = $(+link-static-tests)
+-endif
+-endif
+++link-printers-tests = $(+link-static-tests)
++endif # build-shared
++endif # +link
++
++# The pretty printer test programs need to be compiled without optimizations
++# so they won't confuse gdb. We could use either the 'GCC optimize' pragma
++# or the 'optimize' function attribute to achieve this; however, at least on
++# ARM, gcc always produces different debugging symbols when invoked with
++# a -O greater than 0 than when invoked with -O0, regardless of anything else
++# we're using to suppress optimizations. Therefore, we need to explicitly pass
++# -O0 to it through CFLAGS.
++# Additionally, the build system will try to -include $(common-objpfx)/config.h
++# when compiling the tests, which will throw an error if some special macros
++# (such as __OPTIMIZE__ and IS_IN_build) aren't defined. To avoid this, we
++# tell gcc to define IS_IN_build.
++CFLAGS-printers-tests := -O0 -ggdb3 -DIS_IN_build
++
+ ifeq (yes,$(build-shared))
++# These indicate whether to link using the built ld.so or the installed one.
++installed-rtld-LDFLAGS = -Wl,-dynamic-linker=$(rtlddir)/$(rtld-installed-name)
++built-rtld-LDFLAGS = -Wl,-dynamic-linker=$(elf-objpfx)ld.so
++
+ ifndef rtld-LDFLAGS
+-rtld-LDFLAGS = -Wl,-dynamic-linker=$(rtlddir)/$(rtld-installed-name)
++rtld-LDFLAGS = $(installed-rtld-LDFLAGS)
+ endif
++
+ ifndef rtld-tests-LDFLAGS
+ ifeq (yes,$(build-hardcoded-path-in-tests))
+-rtld-tests-LDFLAGS = -Wl,-dynamic-linker=$(elf-objpfx)ld.so
++rtld-tests-LDFLAGS = $(built-rtld-LDFLAGS)
+ else
+-rtld-tests-LDFLAGS = $(rtld-LDFLAGS)
+-endif
+-endif
+-endif
++rtld-tests-LDFLAGS = $(installed-rtld-LDFLAGS)
++endif # build-hardcoded-path-in-tests
++endif # rtld-tests-LDFLAGS
++
++endif # build-shared
++
+ ifndef link-libc
+ ifeq (yes,$(build-shared))
+ # We need the versioned name of libc.so in the deps of $(others) et al
+ # so that the symlink to libc.so is created before anything tries to
+ # run the linked programs.
++link-libc-rpath = -Wl,-rpath=$(rpath-link)
+ link-libc-rpath-link = -Wl,-rpath-link=$(rpath-link)
++
+ ifeq (yes,$(build-hardcoded-path-in-tests))
+-link-libc-tests-rpath-link = -Wl,-rpath=$(rpath-link)
++link-libc-tests-rpath-link = $(link-libc-rpath)
+ else
+ link-libc-tests-rpath-link = $(link-libc-rpath-link)
+-endif
++endif # build-hardcoded-path-in-tests
++
+ link-libc-before-gnulib = $(common-objpfx)libc.so$(libc.so-version) \
+ $(common-objpfx)$(patsubst %,$(libtype.oS),c) \
+ $(as-needed) $(elf-objpfx)ld.so \
+ $(no-as-needed)
+ link-libc = $(link-libc-rpath-link) $(link-libc-before-gnulib) $(gnulib)
++
++link-libc-tests-after-rpath-link = $(link-libc-before-gnulib) $(gnulib-tests)
+ link-libc-tests = $(link-libc-tests-rpath-link) \
+- $(link-libc-before-gnulib) $(gnulib-tests)
++ $(link-libc-tests-after-rpath-link)
++# Pretty printer test programs always require rpath instead of rpath-link.
++link-libc-printers-tests = $(link-libc-rpath) \
++ $(link-libc-tests-after-rpath-link)
++
+ # This is how to find at build-time things that will be installed there.
+ rpath-dirs = math elf dlfcn nss nis rt resolv crypt mathvec
+ rpath-link = \
+ $(common-objdir):$(subst $(empty) ,:,$(patsubst ../$(subdir),.,$(rpath-dirs:%=$(common-objpfx)%)))
+-else
++else # build-static
+ link-libc = $(common-objpfx)libc.a $(otherlibs) $(gnulib) $(common-objpfx)libc.a $(gnulib)
+ link-libc-tests = $(common-objpfx)libc.a $(otherlibs) $(gnulib-tests) $(common-objpfx)libc.a $(gnulib-tests)
+-endif
+-endif
++endif # build-shared
++endif # link-libc
+
+ # Differences in the linkers on the various platforms.
+ LDFLAGS-rpath-ORIGIN = -Wl,-rpath,'$$ORIGIN'
+diff --git a/Makerules b/Makerules
+index be3c11b..b7e0f59 100644
+--- a/Makerules
++++ b/Makerules
+@@ -214,6 +214,52 @@ sed-remove-dotdot := -e 's@ *\([^ \/$$][^ \]*\)@ $$(..)\1 at g' \
+ -e 's@^\([^ \/$$][^ \]*\)@$$(..)\1 at g'
+ endif
+
++ifdef gen-py-const-headers
++# We'll use a static pattern rule to match .pysym files with their
++# corresponding generated .py files.
++# The generated .py files go in the submodule's dir in the glibc build dir.
++py-const-files := $(patsubst %.pysym,%.py,$(gen-py-const-headers))
++py-const-dir := $(objpfx)
++py-const := $(addprefix $(py-const-dir),$(py-const-files))
++py-const-script := $(..)scripts/gen-py-const.awk
++
++# This is a hack we use to generate .py files with constants for Python
++# pretty printers. It works the same way as gen-as-const.
++# See scripts/gen-py-const.awk for details on how the awk | gcc mechanism
++# works.
++#
++# $@.tmp and $@.tmp2 are temporary files we use to store the partial contents
++# of the target file. We do this instead of just writing on $@ because, if the
++# build process terminates prematurely, re-running Make wouldn't run this rule
++# since Make would see that the target file already exists (despite it being
++# incomplete).
++#
++# The sed line replaces "@name at SOME_NAME@value at SOME_VALUE@" strings from the
++# output of 'gcc -S' with "SOME_NAME = SOME_VALUE" strings.
++# The '-n' option, combined with the '/p' command, makes sed output only the
++# modified lines instead of the whole input file. The output is redirected
++# to a .py file; we'll import it in the pretty printers file to read
++# the constants generated by gen-py-const.awk.
++# The regex has two capturing groups, for SOME_NAME and SOME_VALUE
++# respectively. Notice SOME_VALUE may be prepended by a special character,
++# depending on the assembly syntax (e.g. immediates are prefixed by a '$'
++# in AT&T x86, and by a '#' in ARM). We discard it using a complemented set
++# before the second capturing group.
++$(py-const): $(py-const-dir)%.py: %.pysym $(py-const-script) \
++ $(common-before-compile)
++ $(make-target-directory)
++ $(AWK) -f $(py-const-script) $< \
++ | $(CC) -S -o $@.tmp $(CFLAGS) $(CPPFLAGS) -x c -
++ echo '# GENERATED FILE\n' > $@.tmp2
++ echo '# Constant definitions for pretty printers.' >> $@.tmp2
++ echo '# See gen-py-const.awk for details.\n' >> $@.tmp2
++ sed -n -r 's/^.*@name@([^@]+)@value@[^[:xdigit:]Xx-]*([[:xdigit:]Xx-]+)@.*/\1 = \2/p' \
++ $@.tmp >> $@.tmp2
++ mv -f $@.tmp2 $@
++ rm -f $@.tmp
++
++generated += $(py-const)
++endif # gen-py-const-headers
+
+ ifdef gen-as-const-headers
+ # Generating headers for assembly constants.
+diff --git a/NEWS b/NEWS
+index b0447e7..3002773 100644
+--- a/NEWS
++++ b/NEWS
+@@ -5,6 +5,12 @@ See the end for copying conditions.
+ Please send GNU C library bug reports via <http://sourceware.org/bugzilla/>
+ using `glibc' in the "product" field.
+
++
++* GDB pretty printers have been added for mutex and condition variable
++ structures in POSIX Threads. When installed and loaded in gdb these pretty
++ printers show various pthread variables in human-readable form when read
++ using the 'print' or 'display' commands in gdb.
++
+ Version 2.24
+
+ * The minimum Linux kernel version that this version of the GNU C Library
+diff --git a/README.pretty-printers b/README.pretty-printers
+new file mode 100644
+index 0000000..8662900
+--- /dev/null
++++ b/README.pretty-printers
+@@ -0,0 +1,169 @@
++README for the glibc Python pretty printers
++===========================================
++
++Pretty printers are gdb extensions that allow it to print useful, human-readable
++information about a program's variables. For example, for a pthread_mutex_t
++gdb would usually output something like this:
++
++(gdb) print mutex
++$1 = {
++ __data = {
++ __lock = 22020096,
++ __count = 0,
++ __owner = 0,
++ __nusers = 0,
++ __kind = 576,
++ __spins = 0,
++ __elision = 0,
++ __list = {
++ __prev = 0x0,
++ __next = 0x0
++ }
++ },
++ __size = "\000\000P\001", '\000' <repeats 12 times>, "@\002", '\000' <repeats 21 times>,
++ __align = 22020096
++}
++
++However, with a pretty printer gdb will output something like this:
++
++(gdb) print mutex
++$1 = pthread_mutex_t = {
++ Type = Normal,
++ Status = Unlocked,
++ Robust = No,
++ Shared = No,
++ Protocol = Priority protect,
++ Priority ceiling = 42
++}
++
++Before printing a value, gdb will first check if there's a pretty printer
++registered for it. If there is, it'll use it, otherwise it'll print the value
++as usual. Pretty printers can be registered in various ways; for our purposes
++we register them for the current objfile by calling
++gdb.printing.register_pretty_printer().
++
++Currently our printers are based on gdb.RegexpCollectionPrettyPrinter, which
++means they'll be triggered if the type of the variable we're printing matches
++a given regular expression. For example, MutexPrinter will be triggered if
++our variable's type matches the regexp '^pthread_mutex_t$'.
++
++Besides the printers themselves, each module may have a constants file which the
++printers will import. These constants are generated from C headers during the
++build process, and need to be in the Python search path when loading the
++printers.
++
++
++Installing and loading
++----------------------
++
++The pretty printers and their constant files may be installed in different paths
++for each distro, though gdb should be able to automatically load them by itself.
++When in doubt, you can use the 'info pretty-printer' gdb command to list the
++loaded pretty printers.
++
++If the printers aren't automatically loaded for some reason, you should add the
++following to your .gdbinit:
++
++python
++import sys
++sys.path.insert(0, '/path/to/constants/file/directory')
++end
++
++source /path/to/printers.py
++
++If you're building glibc manually, '/path/to/constants/file/directory' should be
++'/path/to/glibc-build/submodule', where 'submodule' is e.g. nptl.
++
++
++Testing
++-------
++
++The pretty printers come with a small test suite based on PExpect, which is a
++Python module with Expect-like features for spawning and controlling interactive
++programs. Each printer has a corresponding C program and a Python script
++that uses PExpect to drive gdb through the program and compare its output to
++the expected printer's.
++
++The tests run on the glibc host, which is assumed to have both gdb and PExpect;
++if any of those is absent the tests will fail with code 77 (UNSUPPORTED).
++Native builds can be tested simply by doing 'make check'; cross builds must use
++cross-test-ssh.sh as test-wrapper, like this:
++
++make test-wrapper='/path/to/scripts/cross-test-ssh.sh user at host' check
++
++(Remember to share the build system's filesystem with the glibc host's through
++NFS or something similar).
++
++Running 'make check' on a cross build will only compile the test programs,
++without running the scripts.
++
++
++Adding new pretty printers
++--------------------------
++
++Adding new pretty printers to glibc requires following these steps:
++
++1. Identify which constants must be generated from C headers, and write the
++corresponding .pysym file. See scripts/gen-py-const.awk for more information
++on how this works. The name of the .pysym file must be added to the
++'gen-py-const-headers' variable in your submodule's Makefile (without the .pysym
++extension).
++
++2. Write the pretty printer code itself. For this you can follow the gdb
++Python API documentation, and use the existing printers as examples. The printer
++code must import the generated constants file (which will have the same name
++as your .pysym file). The names of the pretty printer files must be added
++to the 'pretty-printers' variable in your submodule's Makefile (without the .py
++extension).
++
++3. Write the unit tests for your pretty printers. The build system calls each
++test script passing it the paths to the test program source, the test program
++binary, and the printer files you added to 'pretty-printers' in the previous
++step. The test scripts, in turn, must import scripts/test_printers_common
++and call the init_test function passing it, among other things, the name of the
++set of pretty printers to enable (as seen by running 'info pretty-printer').
++You can use the existing unit tests as examples.
++
++4. Add the names of the pretty printer tests to the 'tests-printers' variable
++in your submodule's Makefile (without extensions). In addition, for each test
++program you must define a corresponding CFLAGS-* variable and set it to
++$(CFLAGS-printers-tests) to ensure they're compiled correctly. For example,
++test-foo-printer.c requires the following:
++
++CFLAGS-test-foo-printer.c := $(CFLAGS-printers-tests)
++
++Finally, if your programs need to be linked with a specific library, you can add
++its name to the 'tests-printers-libs' variable in your submodule's Makefile.
++
++
++Known issues
++------------
++
++* Pretty printers are inherently coupled to the code they're targetting, thus
++any changes to the target code must also update the corresponding printers.
++On the plus side, the printer code itself may serve as a kind of documentation
++for the target code.
++
++* Older versions of the gdb Python API have a bug where
++gdb.RegexpCollectionPrettyPrinter would not be able to get a value's real type
++if it was typedef'd. This would cause gdb to ignore the pretty printers for
++types like pthread_mutex_t, which is defined as:
++
++typedef union
++{
++ ...
++} pthread_mutex_t;
++
++This was fixed in commit 1b588015839caafc608a6944a78aea170f5fb2f6, and released
++as part of gdb 7.8. However, typedef'ing an already typedef'd type may cause
++a similar issue, e.g.:
++
++typedef pthread_mutex_t mutex;
++mutex a_mutex;
++
++Here, trying to print a_mutex won't trigger the pthread_mutex_t printer.
++
++* The test programs must be compiled without optimizations. This is necessary
++because the test scripts rely on the C code structure being preserved when
++stepping through the programs. Things like aggressive instruction reordering
++or optimizing variables out may make this kind of testing impossible.
+diff --git a/Rules b/Rules
+index 8306d36..10a6479 100644
+--- a/Rules
++++ b/Rules
+@@ -85,16 +85,27 @@ common-generated += dummy.o dummy.c
+
+ .PHONY: others tests bench bench-build
+
++# Test programs for the pretty printers.
++tests-printers-programs := $(addprefix $(objpfx),$(tests-printers))
++
++# .out files with the output of running the pretty printer tests.
++tests-printers-out := $(patsubst %,$(objpfx)%.out,$(tests-printers))
++
+ ifeq ($(build-programs),yes)
+ others: $(addprefix $(objpfx),$(others) $(sysdep-others) $(extra-objs))
+ else
+ others: $(addprefix $(objpfx),$(extra-objs))
+ endif
++
++# Generate constant files for Python pretty printers if required.
++others: $(py-const)
++
+ ifeq ($(run-built-tests),no)
+-tests: $(addprefix $(objpfx),$(tests) $(test-srcs)) $(tests-special)
++tests: $(addprefix $(objpfx),$(tests) $(test-srcs)) $(tests-special) \
++ $(tests-printers-programs)
+ xtests: tests $(xtests-special)
+ else
+-tests: $(tests:%=$(objpfx)%.out) $(tests-special)
++tests: $(tests:%=$(objpfx)%.out) $(tests-special) $(tests-printers-out)
+ xtests: tests $(xtests:%=$(objpfx)%.out) $(xtests-special)
+ endif
+
+@@ -102,7 +113,8 @@ tests-special-notdir = $(patsubst $(objpfx)%, %, $(tests-special))
+ xtests-special-notdir = $(patsubst $(objpfx)%, %, $(xtests-special))
+ tests:
+ $(..)scripts/merge-test-results.sh -s $(objpfx) $(subdir) \
+- $(sort $(tests) $(tests-special-notdir:.out=)) \
++ $(sort $(tests) $(tests-special-notdir:.out=) \
++ $(tests-printers)) \
+ > $(objpfx)subdir-tests.sum
+ xtests:
+ $(..)scripts/merge-test-results.sh -s $(objpfx) $(subdir) \
+@@ -212,6 +224,32 @@ endif
+
+ endif # tests
+
++ifneq "$(strip $(tests-printers))" ""
++# We're defining this here for now; later it'll be defined at configure time
++# inside Makeconfig.
++PYTHON := python
++
++# Static pattern rule for building the test programs for the pretty printers.
++$(tests-printers-programs): %: %.o $(tests-printers-libs) \
++ $(sort $(filter $(common-objpfx)lib%,$(link-libc-static-tests))) \
++ $(addprefix $(csu-objpfx),start.o) $(+preinit) $(+postinit)
++ $(+link-printers-tests)
++
++# Add the paths to the generated constants file and test_common_printers.py
++# to PYTHONPATH so the test scripts can find them.
++py-env := PYTHONPATH=$(py-const-dir):$(..)scripts:$${PYTHONPATH}
++
++# Static pattern rule that matches the test-* targets to their .c and .py
++# prerequisites. It'll run the corresponding test script for each test program
++# we compiled and place its output in the corresponding .out file.
++# The pretty printer files and test_common_printers.py must be present for all.
++$(tests-printers-out): $(objpfx)%.out: $(objpfx)% %.py %.c $(pretty-printers) \
++ $(..)scripts/test_printers_common.py
++ $(test-wrapper-env) $(py-env) \
++ $(PYTHON) $*.py $*.c $(objpfx)$* $(pretty-printers) > $@; \
++ $(evaluate-test)
++endif
++
+
+ .PHONY: distclean realclean subdir_distclean subdir_realclean \
+ subdir_clean subdir_mostlyclean subdir_testclean
+diff --git a/manual/install.texi b/manual/install.texi
+index 79ee45f..468479e 100644
+--- a/manual/install.texi
++++ b/manual/install.texi
+@@ -256,6 +256,36 @@ occurred. You can specify @samp{stop-on-test-failure=y} when running
+ @code{make check} to make the test run stop and exit with an error
+ status immediately when a failure occurs.
+
++The @glibcadj{} pretty printers come with their own set of scripts for testing,
++which run together with the rest of the testsuite through @code{make check}.
++These scripts require the following tools to run successfully:
++
++ at itemize @bullet
++ at item
++Python 2.7.6/3.4.3 or later
++
++Python is required for running the printers' test scripts.
++
++ at item PExpect 4.0
++
++The printer tests drive GDB through test programs and compare its output
++to the printers'. PExpect is used to capture the output of GDB, and should be
++compatible with the Python version in your system.
++
++ at item
++GDB 7.8 or later with support for Python 2.7.6/3.4.3 or later
++
++GDB itself needs to be configured with Python support in order to use the
++pretty printers. Notice that your system having Python available doesn't imply
++that GDB supports it, nor that your system's Python and GDB's have the same
++version.
++ at end itemize
++
++ at noindent
++If these tools are absent, the printer tests will report themselves as
++ at code{UNSUPPORTED}. Notice that some of the printer tests require @theglibc{}
++to be compiled with debugging symbols.
++
+ To format the @cite{GNU C Library Reference Manual} for printing, type
+ @w{@code{make dvi}}. You need a working @TeX{} installation to do
+ this. The distribution builds the on-line formatted version of the
+diff --git a/nptl/Makefile b/nptl/Makefile
+index 7dec4ed..49f6ba6 100644
+--- a/nptl/Makefile
++++ b/nptl/Makefile
+@@ -308,6 +308,24 @@ gen-as-const-headers = pthread-errnos.sym \
+ unwindbuf.sym \
+ lowlevelrobustlock.sym pthread-pi-defines.sym
+
++gen-py-const-headers := nptl_lock_constants.pysym
++pretty-printers := nptl-printers.py
++tests-printers := test-mutexattr-printers test-mutex-printers \
++ test-condattr-printers test-cond-printers \
++ test-rwlockattr-printers test-rwlock-printers
++
++CFLAGS-test-mutexattr-printers.c := $(CFLAGS-printers-tests)
++CFLAGS-test-mutex-printers.c := $(CFLAGS-printers-tests)
++CFLAGS-test-condattr-printers.c := $(CFLAGS-printers-tests)
++CFLAGS-test-cond-printers.c := $(CFLAGS-printers-tests)
++CFLAGS-test-rwlockattr-printers.c := $(CFLAGS-printers-tests)
++CFLAGS-test-rwlock-printers.c := $(CFLAGS-printers-tests)
++
++ifeq ($(build-shared),yes)
++tests-printers-libs := $(shared-thread-library)
++else
++tests-printers-libs := $(static-thread-library)
++endif
+
+ LDFLAGS-pthread.so = -Wl,--enable-new-dtags,-z,nodelete,-z,initfirst
+
+diff --git a/nptl/nptl-printers.py b/nptl/nptl-printers.py
+new file mode 100644
+index 0000000..e402f23
+--- /dev/null
++++ b/nptl/nptl-printers.py
+@@ -0,0 +1,633 @@
++# Pretty printers for the NPTL lock types.
++#
++# Copyright (C) 2016 Free Software Foundation, Inc.
++# This file is part of the GNU C Library.
++#
++# The GNU C Library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# The GNU C Library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with the GNU C Library; if not, see
++# <http://www.gnu.org/licenses/>.
++
++"""This file contains the gdb pretty printers for the following types:
++
++ * pthread_mutex_t
++ * pthread_mutexattr_t
++ * pthread_cond_t
++ * pthread_condattr_t
++ * pthread_rwlock_t
++ * pthread_rwlockattr_t
++
++You can check which printers are registered and enabled by issuing the
++'info pretty-printer' gdb command. Printers should trigger automatically when
++trying to print a variable of one of the types mentioned above.
++"""
++
++from __future__ import print_function
++
++import gdb
++import gdb.printing
++from nptl_lock_constants import *
++
++MUTEX_TYPES = {
++ PTHREAD_MUTEX_NORMAL: ('Type', 'Normal'),
++ PTHREAD_MUTEX_RECURSIVE: ('Type', 'Recursive'),
++ PTHREAD_MUTEX_ERRORCHECK: ('Type', 'Error check'),
++ PTHREAD_MUTEX_ADAPTIVE_NP: ('Type', 'Adaptive')
++}
++
++class MutexPrinter(object):
++ """Pretty printer for pthread_mutex_t."""
++
++ def __init__(self, mutex):
++ """Initialize the printer's internal data structures.
++
++ Args:
++ mutex: A gdb.value representing a pthread_mutex_t.
++ """
++
++ data = mutex['__data']
++ self.lock = data['__lock']
++ self.count = data['__count']
++ self.owner = data['__owner']
++ self.kind = data['__kind']
++ self.values = []
++ self.read_values()
++
++ def to_string(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_mutex_t.
++ """
++
++ return 'pthread_mutex_t'
++
++ def children(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_mutex_t.
++ """
++
++ return self.values
++
++ def read_values(self):
++ """Read the mutex's info and store it in self.values.
++
++ The data contained in self.values will be returned by the Iterator
++ created in self.children.
++ """
++
++ self.read_type()
++ self.read_status()
++ self.read_attributes()
++ self.read_misc_info()
++
++ def read_type(self):
++ """Read the mutex's type."""
++
++ mutex_type = self.kind & PTHREAD_MUTEX_KIND_MASK
++
++ # mutex_type must be casted to int because it's a gdb.Value
++ self.values.append(MUTEX_TYPES[int(mutex_type)])
++
++ def read_status(self):
++ """Read the mutex's status.
++
++ For architectures which support lock elision, this method reads
++ whether the mutex appears as locked in memory (i.e. it may show it as
++ unlocked even after calling pthread_mutex_lock).
++ """
++
++ if self.kind == PTHREAD_MUTEX_DESTROYED:
++ self.values.append(('Status', 'Destroyed'))
++ elif self.kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP:
++ self.read_status_robust()
++ else:
++ self.read_status_no_robust()
++
++ def read_status_robust(self):
++ """Read the status of a robust mutex.
++
++ In glibc robust mutexes are implemented in a very different way than
++ non-robust ones. This method reads their locking status,
++ whether it may have waiters, their registered owner (if any),
++ whether the owner is alive or not, and the status of the state
++ they're protecting.
++ """
++
++ if self.lock == PTHREAD_MUTEX_UNLOCKED:
++ self.values.append(('Status', 'Unlocked'))
++ else:
++ if self.lock & FUTEX_WAITERS:
++ self.values.append(('Status', 'Locked, possibly with waiters'))
++ else:
++ self.values.append(('Status',
++ 'Locked, possibly with no waiters'))
++
++ if self.lock & FUTEX_OWNER_DIED:
++ self.values.append(('Owner ID', '%d (dead)' % self.owner))
++ else:
++ self.values.append(('Owner ID', self.lock & FUTEX_TID_MASK))
++
++ if self.owner == PTHREAD_MUTEX_INCONSISTENT:
++ self.values.append(('State protected by this mutex',
++ 'Inconsistent'))
++ elif self.owner == PTHREAD_MUTEX_NOTRECOVERABLE:
++ self.values.append(('State protected by this mutex',
++ 'Not recoverable'))
++
++ def read_status_no_robust(self):
++ """Read the status of a non-robust mutex.
++
++ Read info on whether the mutex is locked, if it may have waiters
++ and its owner (if any).
++ """
++
++ lock_value = self.lock
++
++ if self.kind & PTHREAD_MUTEX_PRIO_PROTECT_NP:
++ lock_value &= ~(PTHREAD_MUTEX_PRIO_CEILING_MASK)
++
++ if lock_value == PTHREAD_MUTEX_UNLOCKED:
++ self.values.append(('Status', 'Unlocked'))
++ else:
++ if self.kind & PTHREAD_MUTEX_PRIO_INHERIT_NP:
++ waiters = self.lock & FUTEX_WAITERS
++ owner = self.lock & FUTEX_TID_MASK
++ else:
++ # Mutex protocol is PP or none
++ waiters = (self.lock != PTHREAD_MUTEX_LOCKED_NO_WAITERS)
++ owner = self.owner
++
++ if waiters:
++ self.values.append(('Status', 'Locked, possibly with waiters'))
++ else:
++ self.values.append(('Status',
++ 'Locked, possibly with no waiters'))
++
++ self.values.append(('Owner ID', owner))
++
++ def read_attributes(self):
++ """Read the mutex's attributes."""
++
++ if self.kind != PTHREAD_MUTEX_DESTROYED:
++ if self.kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP:
++ self.values.append(('Robust', 'Yes'))
++ else:
++ self.values.append(('Robust', 'No'))
++
++ # In glibc, robust mutexes always have their pshared flag set to
++ # 'shared' regardless of what the pshared flag of their
++ # mutexattr was. Therefore a robust mutex will act as shared
++ # even if it was initialized with a 'private' mutexattr.
++ if self.kind & PTHREAD_MUTEX_PSHARED_BIT:
++ self.values.append(('Shared', 'Yes'))
++ else:
++ self.values.append(('Shared', 'No'))
++
++ if self.kind & PTHREAD_MUTEX_PRIO_INHERIT_NP:
++ self.values.append(('Protocol', 'Priority inherit'))
++ elif self.kind & PTHREAD_MUTEX_PRIO_PROTECT_NP:
++ prio_ceiling = ((self.lock & PTHREAD_MUTEX_PRIO_CEILING_MASK)
++ >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT)
++
++ self.values.append(('Protocol', 'Priority protect'))
++ self.values.append(('Priority ceiling', prio_ceiling))
++ else:
++ # PTHREAD_PRIO_NONE
++ self.values.append(('Protocol', 'None'))
++
++ def read_misc_info(self):
++ """Read miscellaneous info on the mutex.
++
++ For now this reads the number of times a recursive mutex was locked
++ by the same thread.
++ """
++
++ mutex_type = self.kind & PTHREAD_MUTEX_KIND_MASK
++
++ if mutex_type == PTHREAD_MUTEX_RECURSIVE and self.count > 1:
++ self.values.append(('Times locked recursively', self.count))
++
++class MutexAttributesPrinter(object):
++ """Pretty printer for pthread_mutexattr_t.
++
++ In the NPTL this is a type that's always casted to struct pthread_mutexattr
++ which has a single 'mutexkind' field containing the actual attributes.
++ """
++
++ def __init__(self, mutexattr):
++ """Initialize the printer's internal data structures.
++
++ Args:
++ mutexattr: A gdb.value representing a pthread_mutexattr_t.
++ """
++
++ self.values = []
++
++ try:
++ mutexattr_struct = gdb.lookup_type('struct pthread_mutexattr')
++ self.mutexattr = mutexattr.cast(mutexattr_struct)['mutexkind']
++ self.read_values()
++ except gdb.error:
++ # libpthread doesn't have debug symbols, thus we can't find the
++ # real struct type. Just print the union members.
++ self.values.append(('__size', mutexattr['__size']))
++ self.values.append(('__align', mutexattr['__align']))
++
++ def to_string(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_mutexattr_t.
++ """
++
++ return 'pthread_mutexattr_t'
++
++ def children(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_mutexattr_t.
++ """
++
++ return self.values
++
++ def read_values(self):
++ """Read the mutexattr's info and store it in self.values.
++
++ The data contained in self.values will be returned by the Iterator
++ created in self.children.
++ """
++
++ mutexattr_type = (self.mutexattr
++ & ~PTHREAD_MUTEXATTR_FLAG_BITS
++ & ~PTHREAD_MUTEX_NO_ELISION_NP)
++
++ # mutexattr_type must be casted to int because it's a gdb.Value
++ self.values.append(MUTEX_TYPES[int(mutexattr_type)])
++
++ if self.mutexattr & PTHREAD_MUTEXATTR_FLAG_ROBUST:
++ self.values.append(('Robust', 'Yes'))
++ else:
++ self.values.append(('Robust', 'No'))
++
++ if self.mutexattr & PTHREAD_MUTEXATTR_FLAG_PSHARED:
++ self.values.append(('Shared', 'Yes'))
++ else:
++ self.values.append(('Shared', 'No'))
++
++ protocol = ((self.mutexattr & PTHREAD_MUTEXATTR_PROTOCOL_MASK) >>
++ PTHREAD_MUTEXATTR_PROTOCOL_SHIFT)
++
++ if protocol == PTHREAD_PRIO_NONE:
++ self.values.append(('Protocol', 'None'))
++ elif protocol == PTHREAD_PRIO_INHERIT:
++ self.values.append(('Protocol', 'Priority inherit'))
++ elif protocol == PTHREAD_PRIO_PROTECT:
++ self.values.append(('Protocol', 'Priority protect'))
++
++CLOCK_IDS = {
++ CLOCK_REALTIME: 'CLOCK_REALTIME',
++ CLOCK_MONOTONIC: 'CLOCK_MONOTONIC',
++ CLOCK_PROCESS_CPUTIME_ID: 'CLOCK_PROCESS_CPUTIME_ID',
++ CLOCK_THREAD_CPUTIME_ID: 'CLOCK_THREAD_CPUTIME_ID',
++ CLOCK_MONOTONIC_RAW: 'CLOCK_MONOTONIC_RAW',
++ CLOCK_REALTIME_COARSE: 'CLOCK_REALTIME_COARSE',
++ CLOCK_MONOTONIC_COARSE: 'CLOCK_MONOTONIC_COARSE'
++}
++
++class ConditionVariablePrinter(object):
++ """Pretty printer for pthread_cond_t."""
++
++ def __init__(self, cond):
++ """Initialize the printer's internal data structures.
++
++ Args:
++ cond: A gdb.value representing a pthread_cond_t.
++ """
++
++ # Since PTHREAD_COND_SHARED is an integer, we need to cast it to void *
++ # to be able to compare it to the condvar's __data.__mutex member.
++ #
++ # While it looks like self.shared_value should be a class variable,
++ # that would result in it having an incorrect size if we're loading
++ # these printers through .gdbinit for a 64-bit objfile in AMD64.
++ # This is because gdb initially assumes the pointer size to be 4 bytes,
++ # and only sets it to 8 after loading the 64-bit objfiles. Since
++ # .gdbinit runs before any objfiles are loaded, this would effectively
++ # make self.shared_value have a size of 4, thus breaking later
++ # comparisons with pointers whose types are looked up at runtime.
++ void_ptr_type = gdb.lookup_type('void').pointer()
++ self.shared_value = gdb.Value(PTHREAD_COND_SHARED).cast(void_ptr_type)
++
++ data = cond['__data']
++ self.total_seq = data['__total_seq']
++ self.mutex = data['__mutex']
++ self.nwaiters = data['__nwaiters']
++ self.values = []
++
++ self.read_values()
++
++ def to_string(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_cond_t.
++ """
++
++ return 'pthread_cond_t'
++
++ def children(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_cond_t.
++ """
++
++ return self.values
++
++ def read_values(self):
++ """Read the condvar's info and store it in self.values.
++
++ The data contained in self.values will be returned by the Iterator
++ created in self.children.
++ """
++
++ self.read_status()
++ self.read_attributes()
++ self.read_mutex_info()
++
++ def read_status(self):
++ """Read the status of the condvar.
++
++ This method reads whether the condvar is destroyed and how many threads
++ are waiting for it.
++ """
++
++ if self.total_seq == PTHREAD_COND_DESTROYED:
++ self.values.append(('Status', 'Destroyed'))
++
++ self.values.append(('Threads waiting for this condvar',
++ self.nwaiters >> COND_NWAITERS_SHIFT))
++
++ def read_attributes(self):
++ """Read the condvar's attributes."""
++
++ clock_id = self.nwaiters & ((1 << COND_NWAITERS_SHIFT) - 1)
++
++ # clock_id must be casted to int because it's a gdb.Value
++ self.values.append(('Clock ID', CLOCK_IDS[int(clock_id)]))
++
++ shared = (self.mutex == self.shared_value)
++
++ if shared:
++ self.values.append(('Shared', 'Yes'))
++ else:
++ self.values.append(('Shared', 'No'))
++
++ def read_mutex_info(self):
++ """Read the data of the mutex this condvar is bound to.
++
++ A pthread_cond_t's __data.__mutex member is a void * which
++ must be casted to pthread_mutex_t *. For shared condvars, this
++ member isn't recorded and has a special value instead.
++ """
++
++ if self.mutex and self.mutex != self.shared_value:
++ mutex_type = gdb.lookup_type('pthread_mutex_t')
++ mutex = self.mutex.cast(mutex_type.pointer()).dereference()
++
++ self.values.append(('Mutex', mutex))
++
++class ConditionVariableAttributesPrinter(object):
++ """Pretty printer for pthread_condattr_t.
++
++ In the NPTL this is a type that's always casted to struct pthread_condattr,
++ which has a single 'value' field containing the actual attributes.
++ """
++
++ def __init__(self, condattr):
++ """Initialize the printer's internal data structures.
++
++ Args:
++ condattr: A gdb.value representing a pthread_condattr_t.
++ """
++
++ self.values = []
++
++ try:
++ condattr_struct = gdb.lookup_type('struct pthread_condattr')
++ self.condattr = condattr.cast(condattr_struct)['value']
++ self.read_values()
++ except gdb.error:
++ # libpthread doesn't have debug symbols, thus we can't find the
++ # real struct type. Just print the union members.
++ self.values.append(('__size', condattr['__size']))
++ self.values.append(('__align', condattr['__align']))
++
++ def to_string(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_condattr_t.
++ """
++
++ return 'pthread_condattr_t'
++
++ def children(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_condattr_t.
++ """
++
++ return self.values
++
++ def read_values(self):
++ """Read the condattr's info and store it in self.values.
++
++ The data contained in self.values will be returned by the Iterator
++ created in self.children.
++ """
++
++ clock_id = self.condattr & ((1 << COND_NWAITERS_SHIFT) - 1)
++
++ # clock_id must be casted to int because it's a gdb.Value
++ self.values.append(('Clock ID', CLOCK_IDS[int(clock_id)]))
++
++ if self.condattr & 1:
++ self.values.append(('Shared', 'Yes'))
++ else:
++ self.values.append(('Shared', 'No'))
++
++class RWLockPrinter(object):
++ """Pretty printer for pthread_rwlock_t."""
++
++ def __init__(self, rwlock):
++ """Initialize the printer's internal data structures.
++
++ Args:
++ rwlock: A gdb.value representing a pthread_rwlock_t.
++ """
++
++ data = rwlock['__data']
++ self.readers = data['__nr_readers']
++ self.queued_readers = data['__nr_readers_queued']
++ self.queued_writers = data['__nr_writers_queued']
++ self.writer_id = data['__writer']
++ self.shared = data['__shared']
++ self.prefers_writers = data['__flags']
++ self.values = []
++ self.read_values()
++
++ def to_string(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_rwlock_t.
++ """
++
++ return 'pthread_rwlock_t'
++
++ def children(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_rwlock_t.
++ """
++
++ return self.values
++
++ def read_values(self):
++ """Read the rwlock's info and store it in self.values.
++
++ The data contained in self.values will be returned by the Iterator
++ created in self.children.
++ """
++
++ self.read_status()
++ self.read_attributes()
++
++ def read_status(self):
++ """Read the status of the rwlock."""
++
++ # Right now pthread_rwlock_destroy doesn't do anything, so there's no
++ # way to check if an rwlock is destroyed.
++
++ if self.writer_id:
++ self.values.append(('Status', 'Locked (Write)'))
++ self.values.append(('Writer ID', self.writer_id))
++ elif self.readers:
++ self.values.append(('Status', 'Locked (Read)'))
++ self.values.append(('Readers', self.readers))
++ else:
++ self.values.append(('Status', 'Unlocked'))
++
++ self.values.append(('Queued readers', self.queued_readers))
++ self.values.append(('Queued writers', self.queued_writers))
++
++ def read_attributes(self):
++ """Read the attributes of the rwlock."""
++
++ if self.shared:
++ self.values.append(('Shared', 'Yes'))
++ else:
++ self.values.append(('Shared', 'No'))
++
++ if self.prefers_writers:
++ self.values.append(('Prefers', 'Writers'))
++ else:
++ self.values.append(('Prefers', 'Readers'))
++
++class RWLockAttributesPrinter(object):
++ """Pretty printer for pthread_rwlockattr_t.
++
++ In the NPTL this is a type that's always casted to
++ struct pthread_rwlockattr, which has two fields ('lockkind' and 'pshared')
++ containing the actual attributes.
++ """
++
++ def __init__(self, rwlockattr):
++ """Initialize the printer's internal data structures.
++
++ Args:
++ rwlockattr: A gdb.value representing a pthread_rwlockattr_t.
++ """
++
++ self.values = []
++
++ try:
++ rwlockattr_struct = gdb.lookup_type('struct pthread_rwlockattr')
++ self.rwlockattr = rwlockattr.cast(rwlockattr_struct)
++ self.read_values()
++ except gdb.error:
++ # libpthread doesn't have debug symbols, thus we can't find the
++ # real struct type. Just print the union members.
++ self.values.append(('__size', rwlockattr['__size']))
++ self.values.append(('__align', rwlockattr['__align']))
++
++ def to_string(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_rwlockattr_t.
++ """
++
++ return 'pthread_rwlockattr_t'
++
++ def children(self):
++ """gdb API function.
++
++ This is called from gdb when we try to print a pthread_rwlockattr_t.
++ """
++
++ return self.values
++
++ def read_values(self):
++ """Read the rwlockattr's info and store it in self.values.
++
++ The data contained in self.values will be returned by the Iterator
++ created in self.children.
++ """
++
++ rwlock_type = self.rwlockattr['lockkind']
++ shared = self.rwlockattr['pshared']
++
++ if shared == PTHREAD_PROCESS_SHARED:
++ self.values.append(('Shared', 'Yes'))
++ else:
++ # PTHREAD_PROCESS_PRIVATE
++ self.values.append(('Shared', 'No'))
++
++ if (rwlock_type == PTHREAD_RWLOCK_PREFER_READER_NP or
++ rwlock_type == PTHREAD_RWLOCK_PREFER_WRITER_NP):
++ # This is a known bug. Using PTHREAD_RWLOCK_PREFER_WRITER_NP will
++ # still make the rwlock prefer readers.
++ self.values.append(('Prefers', 'Readers'))
++ elif rwlock_type == PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP:
++ self.values.append(('Prefers', 'Writers'))
++
++def register(objfile):
++ """Register the pretty printers within the given objfile."""
++
++ printer = gdb.printing.RegexpCollectionPrettyPrinter('glibc-pthread-locks')
++
++ printer.add_printer('pthread_mutex_t', r'^pthread_mutex_t$',
++ MutexPrinter)
++ printer.add_printer('pthread_mutexattr_t', r'^pthread_mutexattr_t$',
++ MutexAttributesPrinter)
++ printer.add_printer('pthread_cond_t', r'^pthread_cond_t$',
++ ConditionVariablePrinter)
++ printer.add_printer('pthread_condattr_t', r'^pthread_condattr_t$',
++ ConditionVariableAttributesPrinter)
++ printer.add_printer('pthread_rwlock_t', r'^pthread_rwlock_t$',
++ RWLockPrinter)
++ printer.add_printer('pthread_rwlockattr_t', r'^pthread_rwlockattr_t$',
++ RWLockAttributesPrinter)
++
++ if objfile == None:
++ objfile = gdb
++
++ gdb.printing.register_pretty_printer(objfile, printer)
++
++register(gdb.current_objfile())
+diff --git a/nptl/nptl_lock_constants.pysym b/nptl/nptl_lock_constants.pysym
+new file mode 100644
+index 0000000..303ec61
+--- /dev/null
++++ b/nptl/nptl_lock_constants.pysym
+@@ -0,0 +1,75 @@
++#include <pthreadP.h>
++
++-- Mutex types
++PTHREAD_MUTEX_KIND_MASK PTHREAD_MUTEX_KIND_MASK_NP
++PTHREAD_MUTEX_NORMAL
++PTHREAD_MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE_NP
++PTHREAD_MUTEX_ERRORCHECK PTHREAD_MUTEX_ERRORCHECK_NP
++PTHREAD_MUTEX_ADAPTIVE_NP
++
++-- Mutex status
++-- These are hardcoded all over the code; there are no enums/macros for them.
++PTHREAD_MUTEX_DESTROYED -1
++PTHREAD_MUTEX_UNLOCKED 0
++PTHREAD_MUTEX_LOCKED_NO_WAITERS 1
++
++-- For robust mutexes
++PTHREAD_MUTEX_INCONSISTENT
++PTHREAD_MUTEX_NOTRECOVERABLE
++FUTEX_OWNER_DIED
++
++-- For robust and PI mutexes
++FUTEX_WAITERS
++FUTEX_TID_MASK
++
++-- Mutex attributes
++PTHREAD_MUTEX_ROBUST_NORMAL_NP
++PTHREAD_MUTEX_PRIO_INHERIT_NP
++PTHREAD_MUTEX_PRIO_PROTECT_NP
++PTHREAD_MUTEX_PSHARED_BIT
++PTHREAD_MUTEX_PRIO_CEILING_SHIFT
++PTHREAD_MUTEX_PRIO_CEILING_MASK
++
++-- Mutex attribute flags
++PTHREAD_MUTEXATTR_PROTOCOL_SHIFT
++PTHREAD_MUTEXATTR_PROTOCOL_MASK
++PTHREAD_MUTEXATTR_PRIO_CEILING_MASK
++PTHREAD_MUTEXATTR_FLAG_ROBUST
++PTHREAD_MUTEXATTR_FLAG_PSHARED
++PTHREAD_MUTEXATTR_FLAG_BITS
++PTHREAD_MUTEX_NO_ELISION_NP
++
++-- Priority protocols
++PTHREAD_PRIO_NONE
++PTHREAD_PRIO_INHERIT
++PTHREAD_PRIO_PROTECT
++
++-- These values are hardcoded as well:
++-- Value of __mutex for shared condvars.
++PTHREAD_COND_SHARED (void *)~0l
++
++-- Value of __total_seq for destroyed condvars.
++PTHREAD_COND_DESTROYED -1ull
++
++-- __nwaiters encodes the number of threads waiting on a condvar
++-- and the clock ID.
++-- __nwaiters >> COND_NWAITERS_SHIFT gives us the number of waiters.
++COND_NWAITERS_SHIFT
++
++-- Condvar clock IDs
++CLOCK_REALTIME
++CLOCK_MONOTONIC
++CLOCK_PROCESS_CPUTIME_ID
++CLOCK_THREAD_CPUTIME_ID
++CLOCK_MONOTONIC_RAW
++CLOCK_REALTIME_COARSE
++CLOCK_MONOTONIC_COARSE
++
++-- Rwlock attributes
++PTHREAD_RWLOCK_PREFER_READER_NP
++PTHREAD_RWLOCK_PREFER_WRITER_NP
++PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP
++
++-- 'Shared' attribute values
++PTHREAD_PROCESS_PRIVATE
++PTHREAD_PROCESS_SHARED
+diff --git a/nptl/test-cond-printers.c b/nptl/test-cond-printers.c
+new file mode 100644
+index 0000000..0f2a5f4
+--- /dev/null
++++ b/nptl/test-cond-printers.c
+@@ -0,0 +1,57 @@
++/* Helper program for testing the pthread_cond_t pretty printer.
++
++ Copyright (C) 2016 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, see
++ <http://www.gnu.org/licenses/>. */
++
++/* Keep the calls to the pthread_* functions on separate lines to make it easy
++ to advance through the program using the gdb 'next' command. */
++
++#include <time.h>
++#include <pthread.h>
++
++#define PASS 0
++#define FAIL 1
++
++static int test_status_destroyed (pthread_cond_t *condvar);
++
++int
++main (void)
++{
++ pthread_cond_t condvar;
++ pthread_condattr_t attr;
++ int result = FAIL;
++
++ if (pthread_condattr_init (&attr) == 0
++ && test_status_destroyed (&condvar) == PASS)
++ result = PASS;
++ /* Else, one of the pthread_cond* functions failed. */
++
++ return result;
++}
++
++/* Initializes CONDVAR, then destroys it. */
++static int
++test_status_destroyed (pthread_cond_t *condvar)
++{
++ int result = FAIL;
++
++ if (pthread_cond_init (condvar, NULL) == 0
++ && pthread_cond_destroy (condvar) == 0)
++ result = PASS; /* Test status (destroyed). */
++
++ return result;
++}
+diff --git a/nptl/test-cond-printers.py b/nptl/test-cond-printers.py
+new file mode 100644
+index 0000000..af0e12e
+--- /dev/null
++++ b/nptl/test-cond-printers.py
+@@ -0,0 +1,50 @@
++# Common tests for the ConditionVariablePrinter class.
++#
++# Copyright (C) 2016 Free Software Foundation, Inc.
++# This file is part of the GNU C Library.
++#
++# The GNU C Library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# The GNU C Library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with the GNU C Library; if not, see
++# <http://www.gnu.org/licenses/>.
++
++import sys
++
++from test_printers_common import *
++
++test_source = sys.argv[1]
++test_bin = sys.argv[2]
++printer_files = sys.argv[3:]
++printer_names = ['global glibc-pthread-locks']
++
++try:
++ init_test(test_bin, printer_files, printer_names)
++ go_to_main()
++
++ var = 'condvar'
++ to_string = 'pthread_cond_t'
++
++ break_at(test_source, 'Test status (destroyed)')
++ continue_cmd() # Go to test_status_destroyed
++ test_printer(var, to_string, {'Status': 'Destroyed'})
++
++ continue_cmd() # Exit
++
++except (NoLineError, pexpect.TIMEOUT) as exception:
++ print('Error: {0}'.format(exception))
++ result = FAIL
++
++else:
++ print('Test succeeded.')
++ result = PASS
++
++exit(result)
+diff --git a/nptl/test-condattr-printers.c b/nptl/test-condattr-printers.c
+new file mode 100644
+index 0000000..4db4098
+--- /dev/null
++++ b/nptl/test-condattr-printers.c
+@@ -0,0 +1,94 @@
++/* Helper program for testing the pthread_cond_t and pthread_condattr_t
++ pretty printers.
++
++ Copyright (C) 2016 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, see
++ <http://www.gnu.org/licenses/>. */
++
++/* Keep the calls to the pthread_* functions on separate lines to make it easy
++ to advance through the program using the gdb 'next' command. */
++
++#include <time.h>
++#include <pthread.h>
++
++#define PASS 0
++#define FAIL 1
++
++static int condvar_reinit (pthread_cond_t *condvar,
++ const pthread_condattr_t *attr);
++static int test_setclock (pthread_cond_t *condvar, pthread_condattr_t *attr);
++static int test_setpshared (pthread_cond_t *condvar, pthread_condattr_t *attr);
++
++/* Need these so we don't have lines longer than 79 chars. */
++#define SET_SHARED(attr, shared) pthread_condattr_setpshared (attr, shared)
++
++int
++main (void)
++{
++ pthread_cond_t condvar;
++ pthread_condattr_t attr;
++ int result = FAIL;
++
++ if (pthread_condattr_init (&attr) == 0
++ && pthread_cond_init (&condvar, NULL) == 0
++ && test_setclock (&condvar, &attr) == PASS
++ && test_setpshared (&condvar, &attr) == PASS)
++ result = PASS;
++ /* Else, one of the pthread_cond* functions failed. */
++
++ return result;
++}
++
++/* Destroys CONDVAR and re-initializes it using ATTR. */
++static int
++condvar_reinit (pthread_cond_t *condvar, const pthread_condattr_t *attr)
++{
++ int result = FAIL;
++
++ if (pthread_cond_destroy (condvar) == 0
++ && pthread_cond_init (condvar, attr) == 0)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests setting the clock ID attribute. */
++static int
++test_setclock (pthread_cond_t *condvar, pthread_condattr_t *attr)
++{
++ int result = FAIL;
++
++ if (pthread_condattr_setclock (attr, CLOCK_REALTIME) == 0 /* Set clock. */
++ && condvar_reinit (condvar, attr) == PASS)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests setting whether the condvar can be shared between processes. */
++static int
++test_setpshared (pthread_cond_t *condvar, pthread_condattr_t *attr)
++{
++ int result = FAIL;
++
++ if (SET_SHARED (attr, PTHREAD_PROCESS_SHARED) == 0 /* Set shared. */
++ && condvar_reinit (condvar, attr) == PASS
++ && SET_SHARED (attr, PTHREAD_PROCESS_PRIVATE) == 0
++ && condvar_reinit (condvar, attr) == PASS)
++ result = PASS;
++
++ return result;
++}
+diff --git a/nptl/test-condattr-printers.py b/nptl/test-condattr-printers.py
+new file mode 100644
+index 0000000..7ea01db
+--- /dev/null
++++ b/nptl/test-condattr-printers.py
+@@ -0,0 +1,71 @@
++# Common tests for the ConditionVariablePrinter and
++# ConditionVariableAttributesPrinter classes.
++#
++# Copyright (C) 2016 Free Software Foundation, Inc.
++# This file is part of the GNU C Library.
++#
++# The GNU C Library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# The GNU C Library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with the GNU C Library; if not, see
++# <http://www.gnu.org/licenses/>.
++
++import sys
++
++from test_printers_common import *
++
++test_source = sys.argv[1]
++test_bin = sys.argv[2]
++printer_files = sys.argv[3:]
++printer_names = ['global glibc-pthread-locks']
++
++try:
++ init_test(test_bin, printer_files, printer_names)
++ go_to_main()
++
++ check_debug_symbol('struct pthread_condattr')
++
++ condvar_var = 'condvar'
++ condvar_to_string = 'pthread_cond_t'
++
++ attr_var = 'attr'
++ attr_to_string = 'pthread_condattr_t'
++
++ break_at(test_source, 'Set clock')
++ continue_cmd() # Go to test_setclock
++ next_cmd(2)
++ test_printer(condvar_var, condvar_to_string, {'Clock ID': 'CLOCK_REALTIME'})
++ test_printer(attr_var, attr_to_string, {'Clock ID': 'CLOCK_REALTIME'})
++
++ break_at(test_source, 'Set shared')
++ continue_cmd() # Go to test_setpshared
++ next_cmd(2)
++ test_printer(condvar_var, condvar_to_string, {'Shared': 'Yes'})
++ test_printer(attr_var, attr_to_string, {'Shared': 'Yes'})
++ next_cmd(2)
++ test_printer(condvar_var, condvar_to_string, {'Shared': 'No'})
++ test_printer(attr_var, attr_to_string, {'Shared': 'No'})
++
++ continue_cmd() # Exit
++
++except (NoLineError, pexpect.TIMEOUT) as exception:
++ print('Error: {0}'.format(exception))
++ result = FAIL
++
++except DebugError as exception:
++ print(exception)
++ result = UNSUPPORTED
++
++else:
++ print('Test succeeded.')
++ result = PASS
++
++exit(result)
+diff --git a/nptl/test-mutex-printers.c b/nptl/test-mutex-printers.c
+new file mode 100644
+index 0000000..b973e82
+--- /dev/null
++++ b/nptl/test-mutex-printers.c
+@@ -0,0 +1,151 @@
++/* Helper program for testing the pthread_mutex_t pretty printer.
++
++ Copyright (C) 2016 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, see
++ <http://www.gnu.org/licenses/>. */
++
++/* Keep the calls to the pthread_* functions on separate lines to make it easy
++ to advance through the program using the gdb 'next' command. */
++
++#include <stdlib.h>
++#include <errno.h>
++#include <pthread.h>
++
++#define PASS 0
++#define FAIL 1
++
++static int test_status_destroyed (pthread_mutex_t *mutex);
++static int test_status_no_robust (pthread_mutex_t *mutex,
++ pthread_mutexattr_t *attr);
++static int test_status_robust (pthread_mutex_t *mutex,
++ pthread_mutexattr_t *attr);
++static int test_locking_state_robust (pthread_mutex_t *mutex);
++static void *thread_func (void *arg);
++static int test_recursive_locks (pthread_mutex_t *mutex,
++ pthread_mutexattr_t *attr);
++
++int
++main (void)
++{
++ pthread_mutex_t mutex;
++ pthread_mutexattr_t attr;
++ int result = FAIL;
++
++ if (pthread_mutexattr_init (&attr) == 0
++ && test_status_destroyed (&mutex) == PASS
++ && test_status_no_robust (&mutex, &attr) == PASS
++ && test_status_robust (&mutex, &attr) == PASS
++ && test_recursive_locks (&mutex, &attr) == PASS)
++ result = PASS;
++ /* Else, one of the pthread_mutex* functions failed. */
++
++ return result;
++}
++
++/* Initializes MUTEX, then destroys it. */
++static int
++test_status_destroyed (pthread_mutex_t *mutex)
++{
++ int result = FAIL;
++
++ if (pthread_mutex_init (mutex, NULL) == 0
++ && pthread_mutex_destroy (mutex) == 0)
++ result = PASS; /* Test status (destroyed). */
++
++ return result;
++}
++
++/* Tests locking of non-robust mutexes. */
++static int
++test_status_no_robust (pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
++{
++ int result = FAIL;
++
++ if (pthread_mutexattr_setrobust (attr, PTHREAD_MUTEX_STALLED) == 0
++ && pthread_mutex_init (mutex, attr) == 0
++ && pthread_mutex_lock (mutex) == 0 /* Test status (non-robust). */
++ && pthread_mutex_unlock (mutex) == 0
++ && pthread_mutex_destroy (mutex) == 0)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests locking of robust mutexes. */
++static int
++test_status_robust (pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
++{
++ int result = FAIL;
++
++ if (pthread_mutexattr_setrobust (attr, PTHREAD_MUTEX_ROBUST) == 0
++ && pthread_mutex_init (mutex, attr) == 0
++ && test_locking_state_robust (mutex) == PASS /* Test status (robust). */
++ && pthread_mutex_destroy (mutex) == 0)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests locking and state corruption of robust mutexes. We'll mark it as
++ inconsistent, then not recoverable. */
++static int
++test_locking_state_robust (pthread_mutex_t *mutex)
++{
++ int result = FAIL;
++ pthread_t thread;
++
++ if (pthread_create (&thread, NULL, thread_func, mutex) == 0 /* Create. */
++ && pthread_join (thread, NULL) == 0
++ && pthread_mutex_lock (mutex) == EOWNERDEAD /* Test locking (robust). */
++ && pthread_mutex_unlock (mutex) == 0)
++ result = PASS;
++
++ return result;
++}
++
++/* Function to be called by the child thread when testing robust mutexes. */
++static void *
++thread_func (void *arg)
++{
++ pthread_mutex_t *mutex = (pthread_mutex_t *)arg;
++
++ if (pthread_mutex_lock (mutex) != 0) /* Thread function. */
++ exit (FAIL);
++
++ /* Thread terminates without unlocking the mutex, thus marking it as
++ inconsistent. */
++ return NULL;
++}
++
++/* Tests locking the mutex multiple times in a row. */
++static int
++test_recursive_locks (pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
++{
++ int result = FAIL;
++
++ if (pthread_mutexattr_settype (attr, PTHREAD_MUTEX_RECURSIVE) == 0
++ && pthread_mutex_init (mutex, attr) == 0
++ && pthread_mutex_lock (mutex) == 0
++ && pthread_mutex_lock (mutex) == 0
++ && pthread_mutex_lock (mutex) == 0 /* Test recursive locks. */
++ && pthread_mutex_unlock (mutex) == 0
++ && pthread_mutex_unlock (mutex) == 0
++ && pthread_mutex_unlock (mutex) == 0
++ && pthread_mutex_destroy (mutex) == 0)
++ result = PASS;
++
++ return result;
++}
+diff --git a/nptl/test-mutex-printers.py b/nptl/test-mutex-printers.py
+new file mode 100644
+index 0000000..7f542ad
+--- /dev/null
++++ b/nptl/test-mutex-printers.py
+@@ -0,0 +1,97 @@
++# Tests for the MutexPrinter class.
++#
++# Copyright (C) 2016 Free Software Foundation, Inc.
++# This file is part of the GNU C Library.
++#
++# The GNU C Library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# The GNU C Library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with the GNU C Library; if not, see
++# <http://www.gnu.org/licenses/>.
++
++import sys
++
++from test_printers_common import *
++
++test_source = sys.argv[1]
++test_bin = sys.argv[2]
++printer_files = sys.argv[3:]
++printer_names = ['global glibc-pthread-locks']
++
++try:
++ init_test(test_bin, printer_files, printer_names)
++ go_to_main()
++
++ var = 'mutex'
++ to_string = 'pthread_mutex_t'
++
++ break_at(test_source, 'Test status (destroyed)')
++ continue_cmd() # Go to test_status_destroyed
++ test_printer(var, to_string, {'Status': 'Destroyed'})
++
++ break_at(test_source, 'Test status (non-robust)')
++ continue_cmd() # Go to test_status_no_robust
++ test_printer(var, to_string, {'Status': 'Unlocked'})
++ next_cmd()
++ thread_id = get_current_thread_lwpid()
++ test_printer(var, to_string, {'Status': 'Locked, possibly with no waiters',
++ 'Owner ID': thread_id})
++
++ break_at(test_source, 'Test status (robust)')
++ continue_cmd() # Go to test_status_robust
++ test_printer(var, to_string, {'Status': 'Unlocked'})
++
++ # We'll now test the robust mutex locking states. We'll create a new
++ # thread that will lock a robust mutex and exit without unlocking it.
++ break_at(test_source, 'Create')
++ continue_cmd() # Go to test_locking_state_robust
++ # Set a breakpoint for the new thread to hit.
++ break_at(test_source, 'Thread function')
++ continue_cmd()
++ # By now the new thread is created and has hit its breakpoint.
++ set_scheduler_locking(True)
++ parent = 1
++ child = 2
++ select_thread(child)
++ child_id = get_current_thread_lwpid()
++ # We've got the new thread's ID.
++ select_thread(parent)
++ # Make the new thread finish its function while we wait.
++ continue_cmd(thread=child)
++ # The new thread should be dead by now.
++ break_at(test_source, 'Test locking (robust)')
++ continue_cmd()
++ test_printer(var, to_string, {'Owner ID': r'{0} \(dead\)'.format(child_id)})
++ # Try to lock and unlock the mutex.
++ next_cmd()
++ test_printer(var, to_string, {'Owner ID': thread_id,
++ 'State protected by this mutex': 'Inconsistent'})
++ next_cmd()
++ test_printer(var, to_string, {'Status': 'Unlocked',
++ 'State protected by this mutex': 'Not recoverable'})
++ set_scheduler_locking(False)
++
++ break_at(test_source, 'Test recursive locks')
++ continue_cmd() # Go to test_recursive_locks
++ test_printer(var, to_string, {'Times locked recursively': '2'})
++ next_cmd()
++ test_printer(var, to_string, {'Times locked recursively': '3'})
++ continue_cmd() # Exit
++
++except (NoLineError, pexpect.TIMEOUT) as exception:
++ print('Error: {0}'.format(exception))
++ result = FAIL
++
++else:
++ print('Test succeeded.')
++ result = PASS
++
++exit(result)
+diff --git a/nptl/test-mutexattr-printers.c b/nptl/test-mutexattr-printers.c
+new file mode 100644
+index 0000000..9ecfff7
+--- /dev/null
++++ b/nptl/test-mutexattr-printers.c
+@@ -0,0 +1,144 @@
++/* Helper program for testing the pthread_mutex_t and pthread_mutexattr_t
++ pretty printers.
++
++ Copyright (C) 2016 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, see
++ <http://www.gnu.org/licenses/>. */
++
++/* Keep the calls to the pthread_* functions on separate lines to make it easy
++ to advance through the program using the gdb 'next' command. */
++
++#include <pthread.h>
++
++#define PASS 0
++#define FAIL 1
++#define PRIOCEILING 42
++
++/* Need these so we don't have lines longer than 79 chars. */
++#define SET_TYPE(attr, type) pthread_mutexattr_settype (attr, type)
++#define SET_ROBUST(attr, robust) pthread_mutexattr_setrobust (attr, robust)
++#define SET_SHARED(attr, shared) pthread_mutexattr_setpshared (attr, shared)
++#define SET_PROTOCOL(attr, protocol) \
++ pthread_mutexattr_setprotocol (attr, protocol)
++#define SET_PRIOCEILING(mutex, prioceiling, old_ceiling) \
++ pthread_mutex_setprioceiling (mutex, prioceiling, old_ceiling)
++
++static int mutex_reinit (pthread_mutex_t *mutex,
++ const pthread_mutexattr_t *attr);
++static int test_settype (pthread_mutex_t *mutex, pthread_mutexattr_t *attr);
++static int test_setrobust (pthread_mutex_t *mutex, pthread_mutexattr_t *attr);
++static int test_setpshared (pthread_mutex_t *mutex, pthread_mutexattr_t *attr);
++static int test_setprotocol (pthread_mutex_t *mutex,
++ pthread_mutexattr_t *attr);
++
++int
++main (void)
++{
++ pthread_mutex_t mutex;
++ pthread_mutexattr_t attr;
++ int result = FAIL;
++
++ if (pthread_mutexattr_init (&attr) == 0
++ && pthread_mutex_init (&mutex, NULL) == 0
++ && test_settype (&mutex, &attr) == PASS
++ && test_setrobust (&mutex, &attr) == PASS
++ && test_setpshared (&mutex, &attr) == PASS
++ && test_setprotocol (&mutex, &attr) == PASS)
++ result = PASS;
++ /* Else, one of the pthread_mutex* functions failed. */
++
++ return result;
++}
++
++/* Destroys MUTEX and re-initializes it using ATTR. */
++static int
++mutex_reinit (pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
++{
++ int result = FAIL;
++
++ if (pthread_mutex_destroy (mutex) == 0
++ && pthread_mutex_init (mutex, attr) == 0)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests setting the mutex type. */
++static int
++test_settype (pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
++{
++ int result = FAIL;
++
++ if (SET_TYPE (attr, PTHREAD_MUTEX_ERRORCHECK) == 0 /* Set type. */
++ && mutex_reinit (mutex, attr) == 0
++ && SET_TYPE (attr, PTHREAD_MUTEX_RECURSIVE) == 0
++ && mutex_reinit (mutex, attr) == 0
++ && SET_TYPE (attr, PTHREAD_MUTEX_NORMAL) == 0
++ && mutex_reinit (mutex, attr) == 0)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests setting whether the mutex is robust. */
++static int
++test_setrobust (pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
++{
++ int result = FAIL;
++
++ if (SET_ROBUST (attr, PTHREAD_MUTEX_ROBUST) == 0 /* Set robust. */
++ && mutex_reinit (mutex, attr) == 0
++ && SET_ROBUST (attr, PTHREAD_MUTEX_STALLED) == 0
++ && mutex_reinit (mutex, attr) == 0)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests setting whether the mutex can be shared between processes. */
++static int
++test_setpshared (pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
++{
++ int result = FAIL;
++
++ if (SET_SHARED (attr, PTHREAD_PROCESS_SHARED) == 0 /* Set shared. */
++ && mutex_reinit (mutex, attr) == 0
++ && SET_SHARED (attr, PTHREAD_PROCESS_PRIVATE) == 0
++ && mutex_reinit (mutex, attr) == 0)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests setting the mutex protocol and, for Priority Protect, the Priority
++ Ceiling. */
++static int
++test_setprotocol (pthread_mutex_t *mutex, pthread_mutexattr_t *attr)
++{
++ int result = FAIL;
++ int old_prioceiling;
++
++ if (SET_PROTOCOL (attr, PTHREAD_PRIO_INHERIT) == 0 /* Set protocol. */
++ && mutex_reinit (mutex, attr) == 0
++ && SET_PROTOCOL (attr, PTHREAD_PRIO_PROTECT) == 0
++ && mutex_reinit (mutex, attr) == 0
++ && SET_PRIOCEILING(mutex, PRIOCEILING, &old_prioceiling) == 0
++ && SET_PROTOCOL (attr, PTHREAD_PRIO_NONE) == 0
++ && mutex_reinit (mutex, attr) == 0)
++ result = PASS;
++
++ return result;
++}
+diff --git a/nptl/test-mutexattr-printers.py b/nptl/test-mutexattr-printers.py
+new file mode 100644
+index 0000000..4464723
+--- /dev/null
++++ b/nptl/test-mutexattr-printers.py
+@@ -0,0 +1,101 @@
++# Common tests for the MutexPrinter and MutexAttributesPrinter classes.
++#
++# Copyright (C) 2016 Free Software Foundation, Inc.
++# This file is part of the GNU C Library.
++#
++# The GNU C Library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# The GNU C Library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with the GNU C Library; if not, see
++# <http://www.gnu.org/licenses/>.
++
++import sys
++
++from test_printers_common import *
++
++test_source = sys.argv[1]
++test_bin = sys.argv[2]
++printer_files = sys.argv[3:]
++printer_names = ['global glibc-pthread-locks']
++PRIOCEILING = 42
++
++try:
++ init_test(test_bin, printer_files, printer_names)
++ go_to_main()
++
++ check_debug_symbol('struct pthread_mutexattr')
++
++ mutex_var = 'mutex'
++ mutex_to_string = 'pthread_mutex_t'
++
++ attr_var = 'attr'
++ attr_to_string = 'pthread_mutexattr_t'
++
++ break_at(test_source, 'Set type')
++ continue_cmd() # Go to test_settype
++ next_cmd(2)
++ test_printer(attr_var, attr_to_string, {'Type': 'Error check'})
++ test_printer(mutex_var, mutex_to_string, {'Type': 'Error check'})
++ next_cmd(2)
++ test_printer(attr_var, attr_to_string, {'Type': 'Recursive'})
++ test_printer(mutex_var, mutex_to_string, {'Type': 'Recursive'})
++ next_cmd(2)
++ test_printer(attr_var, attr_to_string, {'Type': 'Normal'})
++ test_printer(mutex_var, mutex_to_string, {'Type': 'Normal'})
++
++ break_at(test_source, 'Set robust')
++ continue_cmd() # Go to test_setrobust
++ next_cmd(2)
++ test_printer(attr_var, attr_to_string, {'Robust': 'Yes'})
++ test_printer(mutex_var, mutex_to_string, {'Robust': 'Yes'})
++ next_cmd(2)
++ test_printer(attr_var, attr_to_string, {'Robust': 'No'})
++ test_printer(mutex_var, mutex_to_string, {'Robust': 'No'})
++
++ break_at(test_source, 'Set shared')
++ continue_cmd() # Go to test_setpshared
++ next_cmd(2)
++ test_printer(attr_var, attr_to_string, {'Shared': 'Yes'})
++ test_printer(mutex_var, mutex_to_string, {'Shared': 'Yes'})
++ next_cmd(2)
++ test_printer(attr_var, attr_to_string, {'Shared': 'No'})
++ test_printer(mutex_var, mutex_to_string, {'Shared': 'No'})
++
++ break_at(test_source, 'Set protocol')
++ continue_cmd() # Go to test_setprotocol
++ next_cmd(2)
++ test_printer(attr_var, attr_to_string, {'Protocol': 'Priority inherit'})
++ test_printer(mutex_var, mutex_to_string, {'Protocol': 'Priority inherit'})
++ next_cmd(2)
++ test_printer(attr_var, attr_to_string, {'Protocol': 'Priority protect'})
++ test_printer(mutex_var, mutex_to_string, {'Protocol': 'Priority protect'})
++ next_cmd(2)
++ test_printer(mutex_var, mutex_to_string, {'Priority ceiling':
++ str(PRIOCEILING)})
++ next_cmd()
++ test_printer(attr_var, attr_to_string, {'Protocol': 'None'})
++ test_printer(mutex_var, mutex_to_string, {'Protocol': 'None'})
++
++ continue_cmd() # Exit
++
++except (NoLineError, pexpect.TIMEOUT) as exception:
++ print('Error: {0}'.format(exception))
++ result = FAIL
++
++except DebugError as exception:
++ print(exception)
++ result = UNSUPPORTED
++
++else:
++ print('Test succeeded.')
++ result = PASS
++
++exit(result)
+diff --git a/nptl/test-rwlock-printers.c b/nptl/test-rwlock-printers.c
+new file mode 100644
+index 0000000..dbbe9b8
+--- /dev/null
++++ b/nptl/test-rwlock-printers.c
+@@ -0,0 +1,78 @@
++/* Helper program for testing the pthread_rwlock_t pretty printer.
++
++ Copyright (C) 2016 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, see
++ <http://www.gnu.org/licenses/>. */
++
++/* Keep the calls to the pthread_* functions on separate lines to make it easy
++ to advance through the program using the gdb 'next' command. */
++
++#include <pthread.h>
++
++#define PASS 0
++#define FAIL 1
++
++static int test_locking_reader (pthread_rwlock_t *rwlock);
++static int test_locking_writer (pthread_rwlock_t *rwlock);
++
++int
++main (void)
++{
++ pthread_rwlock_t rwlock;
++
++ int result = FAIL;
++
++ if (test_locking_reader (&rwlock) == PASS
++ && test_locking_writer (&rwlock) == PASS)
++ result = PASS;
++ /* Else, one of the pthread_rwlock* functions failed. */
++
++ return result;
++}
++
++/* Tests locking the rwlock multiple times as a reader. */
++static int
++test_locking_reader (pthread_rwlock_t *rwlock)
++{
++ int result = FAIL;
++
++ if (pthread_rwlock_init (rwlock, NULL) == 0
++ && pthread_rwlock_rdlock (rwlock) == 0 /* Test locking (reader). */
++ && pthread_rwlock_rdlock (rwlock) == 0
++ && pthread_rwlock_rdlock (rwlock) == 0
++ && pthread_rwlock_unlock (rwlock) == 0
++ && pthread_rwlock_unlock (rwlock) == 0
++ && pthread_rwlock_unlock (rwlock) == 0
++ && pthread_rwlock_destroy (rwlock) == 0)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests locking the rwlock as a writer. */
++static int
++test_locking_writer (pthread_rwlock_t *rwlock)
++{
++ int result = FAIL;
++
++ if (pthread_rwlock_init (rwlock, NULL) == 0
++ && pthread_rwlock_wrlock (rwlock) == 0 /* Test locking (writer). */
++ && pthread_rwlock_unlock (rwlock) == 0
++ && pthread_rwlock_destroy (rwlock) == 0)
++ result = PASS;
++
++ return result;
++}
+diff --git a/nptl/test-rwlock-printers.py b/nptl/test-rwlock-printers.py
+new file mode 100644
+index 0000000..b972fa6
+--- /dev/null
++++ b/nptl/test-rwlock-printers.py
+@@ -0,0 +1,64 @@
++# Common tests for the RWLockPrinter class.
++#
++# Copyright (C) 2016 Free Software Foundation, Inc.
++# This file is part of the GNU C Library.
++#
++# The GNU C Library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# The GNU C Library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with the GNU C Library; if not, see
++# <http://www.gnu.org/licenses/>.
++
++import sys
++
++from test_printers_common import *
++
++test_source = sys.argv[1]
++test_bin = sys.argv[2]
++printer_files = sys.argv[3:]
++printer_names = ['global glibc-pthread-locks']
++
++try:
++ init_test(test_bin, printer_files, printer_names)
++ go_to_main()
++
++ var = 'rwlock'
++ to_string = 'pthread_rwlock_t'
++
++ break_at(test_source, 'Test locking (reader)')
++ continue_cmd() # Go to test_locking_reader
++ test_printer(var, to_string, {'Status': 'Unlocked'})
++ next_cmd()
++ test_printer(var, to_string, {'Status': r'Locked \(Read\)', 'Readers': '1'})
++ next_cmd()
++ test_printer(var, to_string, {'Readers': '2'})
++ next_cmd()
++ test_printer(var, to_string, {'Readers': '3'})
++
++ break_at(test_source, 'Test locking (writer)')
++ continue_cmd() # Go to test_locking_writer
++ test_printer(var, to_string, {'Status': 'Unlocked'})
++ next_cmd()
++ thread_id = get_current_thread_lwpid()
++ test_printer(var, to_string, {'Status': r'Locked \(Write\)',
++ 'Writer ID': thread_id})
++
++ continue_cmd() # Exit
++
++except (NoLineError, pexpect.TIMEOUT) as exception:
++ print('Error: {0}'.format(exception))
++ result = FAIL
++
++else:
++ print('Test succeeded.')
++ result = PASS
++
++exit(result)
+diff --git a/nptl/test-rwlockattr-printers.c b/nptl/test-rwlockattr-printers.c
+new file mode 100644
+index 0000000..d12facf
+--- /dev/null
++++ b/nptl/test-rwlockattr-printers.c
+@@ -0,0 +1,98 @@
++/* Helper program for testing the pthread_rwlock_t and pthread_rwlockattr_t
++ pretty printers.
++
++ Copyright (C) 2016 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, see
++ <http://www.gnu.org/licenses/>. */
++
++/* Keep the calls to the pthread_* functions on separate lines to make it easy
++ to advance through the program using the gdb 'next' command. */
++
++#include <pthread.h>
++
++#define PASS 0
++#define FAIL 1
++
++/* Need these so we don't have lines longer than 79 chars. */
++#define SET_KIND(attr, kind) pthread_rwlockattr_setkind_np (attr, kind)
++#define SET_SHARED(attr, shared) pthread_rwlockattr_setpshared (attr, shared)
++
++static int rwlock_reinit (pthread_rwlock_t *rwlock,
++ const pthread_rwlockattr_t *attr);
++static int test_setkind_np (pthread_rwlock_t *rwlock,
++ pthread_rwlockattr_t *attr);
++static int test_setpshared (pthread_rwlock_t *rwlock,
++ pthread_rwlockattr_t *attr);
++
++int
++main (void)
++{
++ pthread_rwlock_t rwlock;
++ pthread_rwlockattr_t attr;
++ int result = FAIL;
++
++ if (pthread_rwlockattr_init (&attr) == 0
++ && pthread_rwlock_init (&rwlock, NULL) == 0
++ && test_setkind_np (&rwlock, &attr) == PASS
++ && test_setpshared (&rwlock, &attr) == PASS)
++ result = PASS;
++ /* Else, one of the pthread_rwlock* functions failed. */
++
++ return result;
++}
++
++/* Destroys RWLOCK and re-initializes it using ATTR. */
++static int
++rwlock_reinit (pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr)
++{
++ int result = FAIL;
++
++ if (pthread_rwlock_destroy (rwlock) == 0
++ && pthread_rwlock_init (rwlock, attr) == 0)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests setting whether the rwlock prefers readers or writers. */
++static int
++test_setkind_np (pthread_rwlock_t *rwlock, pthread_rwlockattr_t *attr)
++{
++ int result = FAIL;
++
++ if (SET_KIND (attr, PTHREAD_RWLOCK_PREFER_READER_NP) == 0 /* Set kind. */
++ && rwlock_reinit (rwlock, attr) == PASS
++ && SET_KIND (attr, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP) == 0
++ && rwlock_reinit (rwlock, attr) == PASS)
++ result = PASS;
++
++ return result;
++}
++
++/* Tests setting whether the rwlock can be shared between processes. */
++static int
++test_setpshared (pthread_rwlock_t *rwlock, pthread_rwlockattr_t *attr)
++{
++ int result = FAIL;
++
++ if (SET_SHARED (attr, PTHREAD_PROCESS_SHARED) == 0 /* Set shared. */
++ && rwlock_reinit (rwlock, attr) == PASS
++ && SET_SHARED (attr, PTHREAD_PROCESS_PRIVATE) == 0
++ && rwlock_reinit (rwlock, attr) == PASS)
++ result = PASS;
++
++ return result;
++}
+diff --git a/nptl/test-rwlockattr-printers.py b/nptl/test-rwlockattr-printers.py
+new file mode 100644
+index 0000000..1ca2dc6
+--- /dev/null
++++ b/nptl/test-rwlockattr-printers.py
+@@ -0,0 +1,73 @@
++# Common tests for the RWLockPrinter and RWLockAttributesPrinter classes.
++#
++# Copyright (C) 2016 Free Software Foundation, Inc.
++# This file is part of the GNU C Library.
++#
++# The GNU C Library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# The GNU C Library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with the GNU C Library; if not, see
++# <http://www.gnu.org/licenses/>.
++
++import sys
++
++from test_printers_common import *
++
++test_source = sys.argv[1]
++test_bin = sys.argv[2]
++printer_files = sys.argv[3:]
++printer_names = ['global glibc-pthread-locks']
++
++try:
++ init_test(test_bin, printer_files, printer_names)
++ go_to_main()
++
++ check_debug_symbol('struct pthread_rwlockattr')
++
++ rwlock_var = 'rwlock'
++ rwlock_to_string = 'pthread_rwlock_t'
++
++ attr_var = 'attr'
++ attr_to_string = 'pthread_rwlockattr_t'
++
++ break_at(test_source, 'Set kind')
++ continue_cmd() # Go to test_setkind_np
++ next_cmd(2)
++ test_printer(rwlock_var, rwlock_to_string, {'Prefers': 'Readers'})
++ test_printer(attr_var, attr_to_string, {'Prefers': 'Readers'})
++ next_cmd(2)
++ test_printer(rwlock_var, rwlock_to_string, {'Prefers': 'Writers'})
++ test_printer(attr_var, attr_to_string, {'Prefers': 'Writers'})
++
++ break_at(test_source, 'Set shared')
++ continue_cmd() # Go to test_setpshared
++ next_cmd(2)
++ test_printer(rwlock_var, rwlock_to_string, {'Shared': 'Yes'})
++ test_printer(attr_var, attr_to_string, {'Shared': 'Yes'})
++ next_cmd(2)
++ test_printer(rwlock_var, rwlock_to_string, {'Shared': 'No'})
++ test_printer(attr_var, attr_to_string, {'Shared': 'No'})
++
++ continue_cmd() # Exit
++
++except (NoLineError, pexpect.TIMEOUT) as exception:
++ print('Error: {0}'.format(exception))
++ result = FAIL
++
++except DebugError as exception:
++ print(exception)
++ result = UNSUPPORTED
++
++else:
++ print('Test succeeded.')
++ result = PASS
++
++exit(result)
+diff --git a/scripts/gen-py-const.awk b/scripts/gen-py-const.awk
+new file mode 100644
+index 0000000..4586f59
+--- /dev/null
++++ b/scripts/gen-py-const.awk
+@@ -0,0 +1,118 @@
++# Script to generate constants for Python pretty printers.
++#
++# Copyright (C) 2016 Free Software Foundation, Inc.
++# This file is part of the GNU C Library.
++#
++# The GNU C Library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# The GNU C Library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with the GNU C Library; if not, see
++# <http://www.gnu.org/licenses/>.
++
++# This script is a smaller version of the clever gen-asm-const.awk hack used to
++# generate ASM constants from .sym files. We'll use this to generate constants
++# for Python pretty printers.
++#
++# The input to this script are .pysym files that look like:
++# #C_Preprocessor_Directive...
++# NAME1
++# NAME2 expression...
++#
++# A line giving just a name implies an expression consisting of just that name.
++# Comments start with '--'.
++#
++# The output of this script is a 'dummy' function containing 'asm' declarations
++# for each non-preprocessor line in the .pysym file. The expression values
++# will appear as input operands to the 'asm' declaration. For example, if we
++# have:
++#
++# /* header.h */
++# #define MACRO 42
++#
++# struct S {
++# char c1;
++# char c2;
++# char c3;
++# };
++#
++# enum E {
++# ZERO,
++# ONE
++# };
++#
++# /* symbols.pysym */
++# #include <stddef.h>
++# #include "header.h"
++# -- This is a comment
++# MACRO
++# C3_OFFSET offsetof(struct S, c3)
++# E_ONE ONE
++#
++# the output will be:
++#
++# #include <stddef.h>
++# #include "header.h"
++# void dummy(void)
++# {
++# asm ("@name at MACRO@value@%0@" : : "i" (MACRO));
++# asm ("@name at C3_OFFSET@value@%0@" : : "i" (offsetof(struct S, c3)));
++# asm ("@name at E_ONE@value@%0@" : : "i" (ONE));
++# }
++#
++# We'll later feed this output to gcc -S. Since '-S' tells gcc to compile but
++# not assemble, gcc will output something like:
++#
++# dummy:
++# ...
++# @name at MACRO@value@$42@
++# @name at C3_OFFSET@value@$2@
++# @name at E_ONE@value@$1@
++#
++# Finally, we can process that output to extract the constant values.
++# Notice gcc may prepend a special character such as '$' to each value.
++
++# found_symbol indicates whether we found a non-comment, non-preprocessor line.
++BEGIN { found_symbol = 0 }
++
++# C preprocessor directives go straight through.
++/^#/ { print; next; }
++
++# Skip comments.
++/--/ { next; }
++
++# Trim leading whitespace.
++{ sub(/^[[:blank:]]*/, ""); }
++
++# If we found a non-comment, non-preprocessor line, print the 'dummy' function
++# header.
++NF > 0 && !found_symbol {
++ print "void dummy(void)\n{";
++ found_symbol = 1;
++}
++
++# If the line contains just a name, duplicate it so we can use that name
++# as the value of the expression.
++NF == 1 { sub(/^.*$/, "& &"); }
++
++# If a line contains a name and an expression...
++NF > 1 {
++ name = $1;
++
++ # Remove any characters before the second field.
++ sub(/^[^[:blank:]]+[[:blank:]]+/, "");
++
++ # '$0' ends up being everything that appeared after the first field
++ # separator.
++ printf " asm (\"@name@%s at value@%0@\" : : \"i\" (%s));\n", name, $0;
++}
++
++# Close the 'dummy' function.
++END { if (found_symbol) print "}"; }
+diff --git a/scripts/test_printers_common.py b/scripts/test_printers_common.py
+new file mode 100644
+index 0000000..c79d7e3
+--- /dev/null
++++ b/scripts/test_printers_common.py
+@@ -0,0 +1,364 @@
++# Common functions and variables for testing the Python pretty printers.
++#
++# Copyright (C) 2016 Free Software Foundation, Inc.
++# This file is part of the GNU C Library.
++#
++# The GNU C Library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# The GNU C Library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with the GNU C Library; if not, see
++# <http://www.gnu.org/licenses/>.
++
++"""These tests require PExpect 4.0 or newer.
++
++Exported constants:
++ PASS, FAIL, UNSUPPORTED (int): Test exit codes, as per evaluate-test.sh.
++"""
++
++import os
++import re
++from test_printers_exceptions import *
++
++PASS = 0
++FAIL = 1
++UNSUPPORTED = 77
++
++gdb_bin = 'gdb'
++gdb_options = '-q -nx'
++gdb_invocation = '{0} {1}'.format(gdb_bin, gdb_options)
++pexpect_min_version = 4
++gdb_min_version = (7, 8)
++encoding = 'utf-8'
++
++try:
++ import pexpect
++except ImportError:
++ print('PExpect 4.0 or newer must be installed to test the pretty printers.')
++ exit(UNSUPPORTED)
++
++pexpect_version = pexpect.__version__.split('.')[0]
++
++if int(pexpect_version) < pexpect_min_version:
++ print('PExpect 4.0 or newer must be installed to test the pretty printers.')
++ exit(UNSUPPORTED)
++
++if not pexpect.which(gdb_bin):
++ print('gdb 7.8 or newer must be installed to test the pretty printers.')
++ exit(UNSUPPORTED)
++
++timeout = 5
++TIMEOUTFACTOR = os.environ.get('TIMEOUTFACTOR')
++
++if TIMEOUTFACTOR:
++ timeout = int(TIMEOUTFACTOR)
++
++try:
++ # Check the gdb version.
++ version_cmd = '{0} --version'.format(gdb_invocation, timeout=timeout)
++ gdb_version_out = pexpect.run(version_cmd, encoding=encoding)
++
++ # The gdb version string is "GNU gdb <PKGVERSION><version>", where
++ # PKGVERSION can be any text. We assume that there'll always be a space
++ # between PKGVERSION and the version number for the sake of the regexp.
++ version_match = re.search(r'GNU gdb .* ([1-9]+)\.([0-9]+)', gdb_version_out)
++
++ if not version_match:
++ print('The gdb version string (gdb -v) is incorrectly formatted.')
++ exit(UNSUPPORTED)
++
++ gdb_version = (int(version_match.group(1)), int(version_match.group(2)))
++
++ if gdb_version < gdb_min_version:
++ print('gdb 7.8 or newer must be installed to test the pretty printers.')
++ exit(UNSUPPORTED)
++
++ # Check if gdb supports Python.
++ gdb_python_cmd = '{0} -ex "python import os" -batch'.format(gdb_invocation,
++ timeout=timeout)
++ gdb_python_error = pexpect.run(gdb_python_cmd, encoding=encoding)
++
++ if gdb_python_error:
++ print('gdb must have python support to test the pretty printers.')
++ exit(UNSUPPORTED)
++
++ # If everything's ok, spawn the gdb process we'll use for testing.
++ gdb = pexpect.spawn(gdb_invocation, echo=False, timeout=timeout,
++ encoding=encoding)
++ gdb_prompt = u'\(gdb\)'
++ gdb.expect(gdb_prompt)
++
++except pexpect.ExceptionPexpect as exception:
++ print('Error: {0}'.format(exception))
++ exit(FAIL)
++
++def test(command, pattern=None):
++ """Sends 'command' to gdb and expects the given 'pattern'.
++
++ If 'pattern' is None, simply consumes everything up to and including
++ the gdb prompt.
++
++ Args:
++ command (string): The command we'll send to gdb.
++ pattern (raw string): A pattern the gdb output should match.
++
++ Returns:
++ string: The string that matched 'pattern', or an empty string if
++ 'pattern' was None.
++ """
++
++ match = ''
++
++ gdb.sendline(command)
++
++ if pattern:
++ # PExpect does a non-greedy match for '+' and '*'. Since it can't look
++ # ahead on the gdb output stream, if 'pattern' ends with a '+' or a '*'
++ # we may end up matching only part of the required output.
++ # To avoid this, we'll consume 'pattern' and anything that follows it
++ # up to and including the gdb prompt, then extract 'pattern' later.
++ index = gdb.expect([u'{0}.+{1}'.format(pattern, gdb_prompt),
++ pexpect.TIMEOUT])
++
++ if index == 0:
++ # gdb.after now contains the whole match. Extract the text that
++ # matches 'pattern'.
++ match = re.match(pattern, gdb.after, re.DOTALL).group()
++ elif index == 1:
++ # We got a timeout exception. Print information on what caused it
++ # and bail out.
++ error = ('Response does not match the expected pattern.\n'
++ 'Command: {0}\n'
++ 'Expected pattern: {1}\n'
++ 'Response: {2}'.format(command, pattern, gdb.before))
++
++ raise pexpect.TIMEOUT(error)
++ else:
++ # Consume just the the gdb prompt.
++ gdb.expect(gdb_prompt)
++
++ return match
++
++def init_test(test_bin, printer_files, printer_names):
++ """Loads the test binary file and the required pretty printers to gdb.
++
++ Args:
++ test_bin (string): The name of the test binary file.
++ pretty_printers (list of strings): A list with the names of the pretty
++ printer files.
++ """
++
++ # Load all the pretty printer files. We're assuming these are safe.
++ for printer_file in printer_files:
++ test('source {0}'.format(printer_file))
++
++ # Disable all the pretty printers.
++ test('disable pretty-printer', r'0 of [0-9]+ printers enabled')
++
++ # Enable only the required printers.
++ for printer in printer_names:
++ test('enable pretty-printer {0}'.format(printer),
++ r'[1-9][0-9]* of [1-9]+ printers enabled')
++
++ # Finally, load the test binary.
++ test('file {0}'.format(test_bin))
++
++def go_to_main():
++ """Executes a gdb 'start' command, which takes us to main."""
++
++ test('start', r'main')
++
++def get_line_number(file_name, string):
++ """Returns the number of the line in which 'string' appears within a file.
++
++ Args:
++ file_name (string): The name of the file we'll search through.
++ string (string): The string we'll look for.
++
++ Returns:
++ int: The number of the line in which 'string' appears, starting from 1.
++ """
++ number = -1
++
++ with open(file_name) as src_file:
++ for i, line in enumerate(src_file):
++ if string in line:
++ number = i + 1
++ break
++
++ if number == -1:
++ raise NoLineError(file_name, string)
++
++ return number
++
++def break_at(file_name, string, temporary=True, thread=None):
++ """Places a breakpoint on the first line in 'file_name' containing 'string'.
++
++ 'string' is usually a comment like "Stop here". Notice this may fail unless
++ the comment is placed inline next to actual code, e.g.:
++
++ ...
++ /* Stop here */
++ ...
++
++ may fail, while:
++
++ ...
++ some_func(); /* Stop here */
++ ...
++
++ will succeed.
++
++ If 'thread' isn't None, the breakpoint will be set for all the threads.
++ Otherwise, it'll be set only for 'thread'.
++
++ Args:
++ file_name (string): The name of the file we'll place the breakpoint in.
++ string (string): A string we'll look for inside the file.
++ We'll place a breakpoint on the line which contains it.
++ temporary (bool): Whether the breakpoint should be automatically deleted
++ after we reach it.
++ thread (int): The number of the thread we'll place the breakpoint for,
++ as seen by gdb. If specified, it should be greater than zero.
++ """
++
++ if not thread:
++ thread_str = ''
++ else:
++ thread_str = 'thread {0}'.format(thread)
++
++ if temporary:
++ command = 'tbreak'
++ break_type = 'Temporary breakpoint'
++ else:
++ command = 'break'
++ break_type = 'Breakpoint'
++
++ line_number = str(get_line_number(file_name, string))
++
++ test('{0} {1}:{2} {3}'.format(command, file_name, line_number, thread_str),
++ r'{0} [0-9]+ at 0x[a-f0-9]+: file {1}, line {2}\.'.format(break_type,
++ file_name,
++ line_number))
++
++def continue_cmd(thread=None):
++ """Executes a gdb 'continue' command.
++
++ If 'thread' isn't None, the command will be applied to all the threads.
++ Otherwise, it'll be applied only to 'thread'.
++
++ Args:
++ thread (int): The number of the thread we'll apply the command to,
++ as seen by gdb. If specified, it should be greater than zero.
++ """
++
++ if not thread:
++ command = 'continue'
++ else:
++ command = 'thread apply {0} continue'.format(thread)
++
++ test(command)
++
++def next_cmd(count=1, thread=None):
++ """Executes a gdb 'next' command.
++
++ If 'thread' isn't None, the command will be applied to all the threads.
++ Otherwise, it'll be applied only to 'thread'.
++
++ Args:
++ count (int): The 'count' argument of the 'next' command.
++ thread (int): The number of the thread we'll apply the command to,
++ as seen by gdb. If specified, it should be greater than zero.
++ """
++
++ if not thread:
++ command = 'next'
++ else:
++ command = 'thread apply {0} next'
++
++ test('{0} {1}'.format(command, count))
++
++def select_thread(thread):
++ """Selects the thread indicated by 'thread'.
++
++ Args:
++ thread (int): The number of the thread we'll switch to, as seen by gdb.
++ This should be greater than zero.
++ """
++
++ if thread > 0:
++ test('thread {0}'.format(thread))
++
++def get_current_thread_lwpid():
++ """Gets the current thread's Lightweight Process ID.
++
++ Returns:
++ string: The current thread's LWP ID.
++ """
++
++ # It's easier to get the LWP ID through the Python API than the gdb CLI.
++ command = 'python print(gdb.selected_thread().ptid[1])'
++
++ return test(command, r'[0-9]+')
++
++def set_scheduler_locking(mode):
++ """Executes the gdb 'set scheduler-locking' command.
++
++ Args:
++ mode (bool): Whether the scheduler locking mode should be 'on'.
++ """
++ modes = {
++ True: 'on',
++ False: 'off'
++ }
++
++ test('set scheduler-locking {0}'.format(modes[mode]))
++
++def test_printer(var, to_string, children=None, is_ptr=True):
++ """ Tests the output of a pretty printer.
++
++ For a variable called 'var', this tests whether its associated printer
++ outputs the expected 'to_string' and children (if any).
++
++ Args:
++ var (string): The name of the variable we'll print.
++ to_string (raw string): The expected output of the printer's 'to_string'
++ method.
++ children (map {raw string->raw string}): A map with the expected output
++ of the printer's children' method.
++ is_ptr (bool): Whether 'var' is a pointer, and thus should be
++ dereferenced.
++ """
++
++ if is_ptr:
++ var = '*{0}'.format(var)
++
++ test('print {0}'.format(var), to_string)
++
++ if children:
++ for name, value in children.items():
++ # Children are shown as 'name = value'.
++ test('print {0}'.format(var), r'{0} = {1}'.format(name, value))
++
++def check_debug_symbol(symbol):
++ """ Tests whether a given debugging symbol exists.
++
++ If the symbol doesn't exist, raises a DebugError.
++
++ Args:
++ symbol (string): The symbol we're going to check for.
++ """
++
++ try:
++ test('ptype {0}'.format(symbol), r'type = {0}'.format(symbol))
++
++ except pexpect.TIMEOUT:
++ # The symbol doesn't exist.
++ raise DebugError(symbol)
+diff --git a/scripts/test_printers_exceptions.py b/scripts/test_printers_exceptions.py
+new file mode 100644
+index 0000000..17034b5
+--- /dev/null
++++ b/scripts/test_printers_exceptions.py
+@@ -0,0 +1,61 @@
++# Exception classes used when testing the Python pretty printers.
++#
++# Copyright (C) 2016 Free Software Foundation, Inc.
++# This file is part of the GNU C Library.
++#
++# The GNU C Library is free software; you can redistribute it and/or
++# modify it under the terms of the GNU Lesser General Public
++# License as published by the Free Software Foundation; either
++# version 2.1 of the License, or (at your option) any later version.
++#
++# The GNU C Library is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++# Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public
++# License along with the GNU C Library; if not, see
++# <http://www.gnu.org/licenses/>.
++
++class NoLineError(Exception):
++ """Custom exception to indicate that a test file doesn't contain
++ the requested string.
++ """
++
++ def __init__(self, file_name, string):
++ """Constructor.
++
++ Args:
++ file_name (string): The name of the test file.
++ string (string): The string that was requested.
++ """
++
++ super(NoLineError, self).__init__()
++ self.file_name = file_name
++ self.string = string
++
++ def __str__(self):
++ """Shows a readable representation of the exception."""
++
++ return ('File {0} has no line containing the following string: {1}'
++ .format(self.file_name, self.string))
++
++class DebugError(Exception):
++ """Custom exception to indicate that a required debugging symbol is missing.
++ """
++
++ def __init__(self, symbol):
++ """Constructor.
++
++ Args:
++ symbol (string): The name of the entity whose debug info is missing.
++ """
++
++ super(DebugError, self).__init__()
++ self.symbol = symbol
++
++ def __str__(self):
++ """Shows a readable representation of the exception."""
++
++ return ('The required debugging information for {0} is missing.'
++ .format(self.symbol))
+--
+2.10.2
+
diff --git a/meta/recipes-core/glibc/glibc/0004-New-condvar-implementation-that-provides-stronger-or.patch b/meta/recipes-core/glibc/glibc/0004-New-condvar-implementation-that-provides-stronger-or.patch
new file mode 100644
index 0000000..3c7bfa1
--- /dev/null
+++ b/meta/recipes-core/glibc/glibc/0004-New-condvar-implementation-that-provides-stronger-or.patch
@@ -0,0 +1,7171 @@
+From 27af8689a6ba8d182f3cbe6ba42cc654ceed0351 Mon Sep 17 00:00:00 2001
+From: Catalin Enache <catalin.enache at windriver.com>
+Date: Fri, 30 Jun 2017 11:56:41 +0300
+Subject: [PATCH 4/6] New condvar implementation that provides stronger
+ ordering guarantees.
+
+This is a new implementation for condition variables, required
+after http://austingroupbugs.net/view.php?id=609 to fix bug 13165. In
+essence, we need to be stricter in which waiters a signal or broadcast
+is required to wake up; this couldn't be solved using the old algorithm.
+ISO C++ made a similar clarification, so this also fixes a bug in
+current libstdc++, for example.
+
+We can't use the old algorithm anymore because futexes do not guarantee
+to wake in FIFO order. Thus, when we wake, we can't simply let any
+waiter grab a signal, but we need to ensure that one of the waiters
+happening before the signal is woken up. This is something the previous
+algorithm violated (see bug 13165).
+
+There's another issue specific to condvars: ABA issues on the underlying
+futexes. Unlike mutexes that have just three states, or semaphores that
+have no tokens or a limited number of them, the state of a condvar is
+the *order* of the waiters. A waiter on a semaphore can grab a token
+whenever one is available; a condvar waiter must only consume a signal
+if it is eligible to do so as determined by the relative order of the
+waiter and the signal.
+Therefore, this new algorithm maintains two groups of waiters: Those
+eligible to consume signals (G1), and those that have to wait until
+previous waiters have consumed signals (G2). Once G1 is empty, G2
+becomes the new G1. 64b counters are used to avoid ABA issues.
+
+This condvar doesn't yet use a requeue optimization (ie, on a broadcast,
+waking just one thread and requeueing all others on the futex of the
+mutex supplied by the program). I don't think doing the requeue is
+necessarily the right approach (but I haven't done real measurements
+yet):
+* If a program expects to wake many threads at the same time and make
+that scalable, a condvar isn't great anyway because of how it requires
+waiters to operate mutually exclusive (due to the mutex usage). Thus, a
+thundering herd problem is a scalability problem with or without the
+optimization. Using something like a semaphore might be more
+appropriate in such a case.
+* The scalability problem is actually at the mutex side; the condvar
+could help (and it tries to with the requeue optimization), but it
+should be the mutex who decides how that is done, and whether it is done
+at all.
+* Forcing all but one waiter into the kernel-side wait queue of the
+mutex prevents/avoids the use of lock elision on the mutex. Thus, it
+prevents the only cure against the underlying scalability problem
+inherent to condvars.
+* If condvars use short critical sections (ie, hold the mutex just to
+check a binary flag or such), which they should do ideally, then forcing
+all those waiter to proceed serially with kernel-based hand-off (ie,
+futex ops in the mutex' contended state, via the futex wait queues) will
+be less efficient than just letting a scalable mutex implementation take
+care of it. Our current mutex impl doesn't employ spinning at all, but
+if critical sections are short, spinning can be much better.
+* Doing the requeue stuff requires all waiters to always drive the mutex
+into the contended state. This leads to each waiter having to call
+futex_wake after lock release, even if this wouldn't be necessary.
+
+ [BZ #13165]
+ * nptl/pthread_cond_broadcast.c (__pthread_cond_broadcast): Rewrite to
+ use new algorithm.
+ * nptl/pthread_cond_destroy.c (__pthread_cond_destroy): Likewise.
+ * nptl/pthread_cond_init.c (__pthread_cond_init): Likewise.
+ * nptl/pthread_cond_signal.c (__pthread_cond_signal): Likewise.
+ * nptl/pthread_cond_wait.c (__pthread_cond_wait): Likewise.
+ (__pthread_cond_timedwait): Move here from pthread_cond_timedwait.c.
+ (__condvar_confirm_wakeup, __condvar_cancel_waiting,
+ __condvar_cleanup_waiting, __condvar_dec_grefs,
+ __pthread_cond_wait_common): New.
+ (__condvar_cleanup): Remove.
+ * npt/pthread_condattr_getclock.c (pthread_condattr_getclock): Adapt.
+ * npt/pthread_condattr_setclock.c (pthread_condattr_setclock):
+ Likewise.
+ * npt/pthread_condattr_getpshared.c (pthread_condattr_getpshared):
+ Likewise.
+ * npt/pthread_condattr_init.c (pthread_condattr_init): Likewise.
+ * nptl/tst-cond1.c: Add comment.
+ * nptl/tst-cond20.c (do_test): Adapt.
+ * nptl/tst-cond22.c (do_test): Likewise.
+ * sysdeps/aarch64/nptl/bits/pthreadtypes.h (pthread_cond_t): Adapt
+ structure.
+ * sysdeps/arm/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
+ * sysdeps/ia64/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
+ * sysdeps/m68k/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
+ * sysdeps/microblaze/nptl/bits/pthreadtypes.h (pthread_cond_t):
+ Likewise.
+ * sysdeps/mips/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
+ * sysdeps/nios2/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
+ * sysdeps/s390/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
+ * sysdeps/sh/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
+ * sysdeps/tile/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
+ * sysdeps/unix/sysv/linux/alpha/bits/pthreadtypes.h (pthread_cond_t):
+ Likewise.
+ * sysdeps/unix/sysv/linux/powerpc/bits/pthreadtypes.h (pthread_cond_t):
+ Likewise.
+ * sysdeps/x86/bits/pthreadtypes.h (pthread_cond_t): Likewise.
+ * sysdeps/nptl/internaltypes.h (COND_NWAITERS_SHIFT): Remove.
+ (COND_CLOCK_BITS): Adapt.
+ * sysdeps/nptl/pthread.h (PTHREAD_COND_INITIALIZER): Adapt.
+ * nptl/pthreadP.h (__PTHREAD_COND_CLOCK_MONOTONIC_MASK,
+ __PTHREAD_COND_SHARED_MASK): New.
+ * nptl/nptl-printers.py (CLOCK_IDS): Remove.
+ (ConditionVariablePrinter, ConditionVariableAttributesPrinter): Adapt.
+ * nptl/nptl_lock_constants.pysym: Adapt.
+ * nptl/test-cond-printers.py: Adapt.
+ * sysdeps/unix/sysv/linux/hppa/internaltypes.h (cond_compat_clear,
+ cond_compat_check_and_clear): Adapt.
+ * sysdeps/unix/sysv/linux/hppa/pthread_cond_timedwait.c: Remove file ...
+ * sysdeps/unix/sysv/linux/hppa/pthread_cond_wait.c
+ (__pthread_cond_timedwait): ... and move here.
+ * nptl/DESIGN-condvar.txt: Remove file.
+ * nptl/lowlevelcond.sym: Likewise.
+ * nptl/pthread_cond_timedwait.c: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_broadcast.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_signal.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i586/pthread_cond_broadcast.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i586/pthread_cond_signal.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i586/pthread_cond_timedwait.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i586/pthread_cond_wait.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i686/pthread_cond_broadcast.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i686/pthread_cond_signal.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i686/pthread_cond_timedwait.S: Likewise.
+ * sysdeps/unix/sysv/linux/i386/i686/pthread_cond_wait.S: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S: Likewise.
+ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S: Likewise.
+
+Upstream-Status: Backport
+
+Author: Torvald Riegel <triegel at redhat.com>
+Signed-off-by: Catalin Enache <catalin.enache at windriver.com>
+---
+ ChangeLog | 74 ++
+ nptl/DESIGN-condvar.txt | 134 ---
+ nptl/Makefile | 6 +-
+ nptl/lowlevelcond.sym | 16 -
+ nptl/nptl-printers.py | 70 +-
+ nptl/nptl_lock_constants.pysym | 27 +-
+ nptl/pthreadP.h | 7 +
+ nptl/pthread_cond_broadcast.c | 99 ++-
+ nptl/pthread_cond_common.c | 466 ++++++++++
+ nptl/pthread_cond_destroy.c | 82 +-
+ nptl/pthread_cond_init.c | 28 +-
+ nptl/pthread_cond_signal.c | 99 ++-
+ nptl/pthread_cond_timedwait.c | 268 ------
+ nptl/pthread_cond_wait.c | 754 ++++++++++++----
+ nptl/pthread_condattr_getclock.c | 2 +-
+ nptl/pthread_condattr_getpshared.c | 3 +-
+ nptl/pthread_condattr_init.c | 4 +-
+ nptl/pthread_condattr_setclock.c | 11 +-
+ nptl/test-cond-printers.py | 2 +-
+ nptl/tst-cond1.c | 3 +
+ nptl/tst-cond20.c | 5 +-
+ nptl/tst-cond22.c | 18 +-
+ sysdeps/aarch64/nptl/bits/pthreadtypes.h | 31 +-
+ sysdeps/arm/nptl/bits/pthreadtypes.h | 29 +-
+ sysdeps/ia64/nptl/bits/pthreadtypes.h | 31 +-
+ sysdeps/m68k/nptl/bits/pthreadtypes.h | 32 +-
+ sysdeps/microblaze/nptl/bits/pthreadtypes.h | 29 +-
+ sysdeps/mips/nptl/bits/pthreadtypes.h | 31 +-
+ sysdeps/nios2/nptl/bits/pthreadtypes.h | 31 +-
+ sysdeps/nptl/internaltypes.h | 17 +-
+ sysdeps/nptl/pthread.h | 2 +-
+ sysdeps/s390/nptl/bits/pthreadtypes.h | 29 +-
+ sysdeps/sh/nptl/bits/pthreadtypes.h | 29 +-
+ sysdeps/tile/nptl/bits/pthreadtypes.h | 29 +-
+ sysdeps/unix/sysv/linux/alpha/bits/pthreadtypes.h | 31 +-
+ sysdeps/unix/sysv/linux/hppa/internaltypes.h | 40 +-
+ .../unix/sysv/linux/hppa/pthread_cond_timedwait.c | 41 -
+ sysdeps/unix/sysv/linux/hppa/pthread_cond_wait.c | 13 +
+ .../sysv/linux/i386/i686/pthread_cond_timedwait.S | 20 -
+ .../unix/sysv/linux/i386/pthread_cond_broadcast.S | 241 -----
+ sysdeps/unix/sysv/linux/i386/pthread_cond_signal.S | 216 -----
+ .../unix/sysv/linux/i386/pthread_cond_timedwait.S | 974 ---------------------
+ sysdeps/unix/sysv/linux/i386/pthread_cond_wait.S | 642 --------------
+ .../unix/sysv/linux/powerpc/bits/pthreadtypes.h | 31 +-
+ .../sysv/linux/x86_64/pthread_cond_broadcast.S | 177 ----
+ .../unix/sysv/linux/x86_64/pthread_cond_signal.S | 161 ----
+ .../sysv/linux/x86_64/pthread_cond_timedwait.S | 623 -------------
+ sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S | 555 ------------
+ sysdeps/x86/bits/pthreadtypes.h | 29 +-
+ 49 files changed, 1671 insertions(+), 4621 deletions(-)
+ delete mode 100644 nptl/DESIGN-condvar.txt
+ delete mode 100644 nptl/lowlevelcond.sym
+ create mode 100644 nptl/pthread_cond_common.c
+ delete mode 100644 nptl/pthread_cond_timedwait.c
+ delete mode 100644 sysdeps/unix/sysv/linux/hppa/pthread_cond_timedwait.c
+ delete mode 100644 sysdeps/unix/sysv/linux/i386/i686/pthread_cond_timedwait.S
+ delete mode 100644 sysdeps/unix/sysv/linux/i386/pthread_cond_broadcast.S
+ delete mode 100644 sysdeps/unix/sysv/linux/i386/pthread_cond_signal.S
+ delete mode 100644 sysdeps/unix/sysv/linux/i386/pthread_cond_timedwait.S
+ delete mode 100644 sysdeps/unix/sysv/linux/i386/pthread_cond_wait.S
+ delete mode 100644 sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S
+ delete mode 100644 sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S
+ delete mode 100644 sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S
+ delete mode 100644 sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S
+
+diff --git a/ChangeLog b/ChangeLog
+index 8036c1e..c94db7b 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,77 @@
++2016-12-31 Torvald Riegel <triegel at redhat.com>
++
++ [BZ #13165]
++ * nptl/pthread_cond_broadcast.c (__pthread_cond_broadcast): Rewrite to
++ use new algorithm.
++ * nptl/pthread_cond_destroy.c (__pthread_cond_destroy): Likewise.
++ * nptl/pthread_cond_init.c (__pthread_cond_init): Likewise.
++ * nptl/pthread_cond_signal.c (__pthread_cond_signal): Likewise.
++ * nptl/pthread_cond_wait.c (__pthread_cond_wait): Likewise.
++ (__pthread_cond_timedwait): Move here from pthread_cond_timedwait.c.
++ (__condvar_confirm_wakeup, __condvar_cancel_waiting,
++ __condvar_cleanup_waiting, __condvar_dec_grefs,
++ __pthread_cond_wait_common): New.
++ (__condvar_cleanup): Remove.
++ * npt/pthread_condattr_getclock.c (pthread_condattr_getclock): Adapt.
++ * npt/pthread_condattr_setclock.c (pthread_condattr_setclock):
++ Likewise.
++ * npt/pthread_condattr_getpshared.c (pthread_condattr_getpshared):
++ Likewise.
++ * npt/pthread_condattr_init.c (pthread_condattr_init): Likewise.
++ * nptl/tst-cond1.c: Add comment.
++ * nptl/tst-cond20.c (do_test): Adapt.
++ * nptl/tst-cond22.c (do_test): Likewise.
++ * sysdeps/aarch64/nptl/bits/pthreadtypes.h (pthread_cond_t): Adapt
++ structure.
++ * sysdeps/arm/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
++ * sysdeps/ia64/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
++ * sysdeps/m68k/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
++ * sysdeps/microblaze/nptl/bits/pthreadtypes.h (pthread_cond_t):
++ Likewise.
++ * sysdeps/mips/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
++ * sysdeps/nios2/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
++ * sysdeps/s390/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
++ * sysdeps/sh/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
++ * sysdeps/tile/nptl/bits/pthreadtypes.h (pthread_cond_t): Likewise.
++ * sysdeps/unix/sysv/linux/alpha/bits/pthreadtypes.h (pthread_cond_t):
++ Likewise.
++ * sysdeps/unix/sysv/linux/powerpc/bits/pthreadtypes.h (pthread_cond_t):
++ Likewise.
++ * sysdeps/x86/bits/pthreadtypes.h (pthread_cond_t): Likewise.
++ * sysdeps/nptl/internaltypes.h (COND_NWAITERS_SHIFT): Remove.
++ (COND_CLOCK_BITS): Adapt.
++ * sysdeps/nptl/pthread.h (PTHREAD_COND_INITIALIZER): Adapt.
++ * nptl/pthreadP.h (__PTHREAD_COND_CLOCK_MONOTONIC_MASK,
++ __PTHREAD_COND_SHARED_MASK): New.
++ * nptl/nptl-printers.py (CLOCK_IDS): Remove.
++ (ConditionVariablePrinter, ConditionVariableAttributesPrinter): Adapt.
++ * nptl/nptl_lock_constants.pysym: Adapt.
++ * nptl/test-cond-printers.py: Adapt.
++ * sysdeps/unix/sysv/linux/hppa/internaltypes.h (cond_compat_clear,
++ cond_compat_check_and_clear): Adapt.
++ * sysdeps/unix/sysv/linux/hppa/pthread_cond_timedwait.c: Remove file ...
++ * sysdeps/unix/sysv/linux/hppa/pthread_cond_wait.c
++ (__pthread_cond_timedwait): ... and move here.
++ * nptl/DESIGN-condvar.txt: Remove file.
++ * nptl/lowlevelcond.sym: Likewise.
++ * nptl/pthread_cond_timedwait.c: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_broadcast.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_signal.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i586/pthread_cond_broadcast.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i586/pthread_cond_signal.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i586/pthread_cond_timedwait.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i586/pthread_cond_wait.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i686/pthread_cond_broadcast.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i686/pthread_cond_signal.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i686/pthread_cond_timedwait.S: Likewise.
++ * sysdeps/unix/sysv/linux/i386/i686/pthread_cond_wait.S: Likewise.
++ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S: Likewise.
++ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S: Likewise.
++ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S: Likewise.
++ * sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S: Likewise.
++
+ 2016-12-08 Martin Galvan <martin.galvan at tallertechnologies.com>
+
+ * INSTALL: Regenerated.
+diff --git a/nptl/DESIGN-condvar.txt b/nptl/DESIGN-condvar.txt
+deleted file mode 100644
+index 4845251..0000000
+--- a/nptl/DESIGN-condvar.txt
++++ /dev/null
+@@ -1,134 +0,0 @@
+-Conditional Variable pseudocode.
+-================================
+-
+- int pthread_cond_timedwait (pthread_cond_t *cv, pthread_mutex_t *mutex);
+- int pthread_cond_signal (pthread_cond_t *cv);
+- int pthread_cond_broadcast (pthread_cond_t *cv);
+-
+-struct pthread_cond_t {
+-
+- unsigned int cond_lock;
+-
+- internal mutex
+-
+- uint64_t total_seq;
+-
+- Total number of threads using the conditional variable.
+-
+- uint64_t wakeup_seq;
+-
+- sequence number for next wakeup.
+-
+- uint64_t woken_seq;
+-
+- sequence number of last woken thread.
+-
+- uint32_t broadcast_seq;
+-
+-}
+-
+-
+-struct cv_data {
+-
+- pthread_cond_t *cv;
+-
+- uint32_t bc_seq
+-
+-}
+-
+-
+-
+-cleanup_handler(cv_data)
+-{
+- cv = cv_data->cv;
+- lll_lock(cv->lock);
+-
+- if (cv_data->bc_seq == cv->broadcast_seq) {
+- ++cv->wakeup_seq;
+- ++cv->woken_seq;
+- }
+-
+- /* make sure no signal gets lost. */
+- FUTEX_WAKE(cv->wakeup_seq, ALL);
+-
+- lll_unlock(cv->lock);
+-}
+-
+-
+-cond_timedwait(cv, mutex, timeout):
+-{
+- lll_lock(cv->lock);
+- mutex_unlock(mutex);
+-
+- cleanup_push
+-
+- ++cv->total_seq;
+- val = seq = cv->wakeup_seq;
+- cv_data.bc = cv->broadcast_seq;
+- cv_data.cv = cv;
+-
+- while (1) {
+-
+- lll_unlock(cv->lock);
+-
+- enable_async(&cv_data);
+-
+- ret = FUTEX_WAIT(cv->wakeup_seq, val, timeout);
+-
+- restore_async
+-
+- lll_lock(cv->lock);
+-
+- if (bc != cv->broadcast_seq)
+- goto bc_out;
+-
+- val = cv->wakeup_seq;
+-
+- if (val != seq && cv->woken_seq != val) {
+- ret = 0;
+- break;
+- }
+-
+- if (ret == TIMEDOUT) {
+- ++cv->wakeup_seq;
+- break;
+- }
+- }
+-
+- ++cv->woken_seq;
+-
+- bc_out:
+- lll_unlock(cv->lock);
+-
+- cleanup_pop
+-
+- mutex_lock(mutex);
+-
+- return ret;
+-}
+-
+-cond_signal(cv)
+-{
+- lll_lock(cv->lock);
+-
+- if (cv->total_seq > cv->wakeup_seq) {
+- ++cv->wakeup_seq;
+- FUTEX_WAKE(cv->wakeup_seq, 1);
+- }
+-
+- lll_unlock(cv->lock);
+-}
+-
+-cond_broadcast(cv)
+-{
+- lll_lock(cv->lock);
+-
+- if (cv->total_seq > cv->wakeup_seq) {
+- cv->wakeup_seq = cv->total_seq;
+- cv->woken_seq = cv->total_seq;
+- ++cv->broadcast_seq;
+- FUTEX_WAKE(cv->wakeup_seq, ALL);
+- }
+-
+- lll_unlock(cv->lock);
+-}
+diff --git a/nptl/Makefile b/nptl/Makefile
+index 49f6ba6..1f0674c 100644
+--- a/nptl/Makefile
++++ b/nptl/Makefile
+@@ -71,7 +71,7 @@ libpthread-routines = nptl-init vars events version pt-interp \
+ pthread_rwlockattr_getkind_np \
+ pthread_rwlockattr_setkind_np \
+ pthread_cond_init pthread_cond_destroy \
+- pthread_cond_wait pthread_cond_timedwait \
++ pthread_cond_wait \
+ pthread_cond_signal pthread_cond_broadcast \
+ old_pthread_cond_init old_pthread_cond_destroy \
+ old_pthread_cond_wait old_pthread_cond_timedwait \
+@@ -181,7 +181,6 @@ CFLAGS-pthread_timedjoin.c = -fexceptions -fasynchronous-unwind-tables
+ CFLAGS-pthread_once.c = $(uses-callbacks) -fexceptions \
+ -fasynchronous-unwind-tables
+ CFLAGS-pthread_cond_wait.c = -fexceptions -fasynchronous-unwind-tables
+-CFLAGS-pthread_cond_timedwait.c = -fexceptions -fasynchronous-unwind-tables
+ CFLAGS-sem_wait.c = -fexceptions -fasynchronous-unwind-tables
+ CFLAGS-sem_timedwait.c = -fexceptions -fasynchronous-unwind-tables
+
+@@ -303,8 +302,7 @@ test-xfail-tst-once5 = yes
+ # Files which must not be linked with libpthread.
+ tests-nolibpthread = tst-unload
+
+-gen-as-const-headers = pthread-errnos.sym \
+- lowlevelcond.sym lowlevelrwlock.sym \
++gen-as-const-headers = pthread-errnos.sym lowlevelrwlock.sym \
+ unwindbuf.sym \
+ lowlevelrobustlock.sym pthread-pi-defines.sym
+
+diff --git a/nptl/lowlevelcond.sym b/nptl/lowlevelcond.sym
+deleted file mode 100644
+index 18e1ada..0000000
+--- a/nptl/lowlevelcond.sym
++++ /dev/null
+@@ -1,16 +0,0 @@
+-#include <stddef.h>
+-#include <sched.h>
+-#include <bits/pthreadtypes.h>
+-#include <internaltypes.h>
+-
+---
+-
+-cond_lock offsetof (pthread_cond_t, __data.__lock)
+-cond_futex offsetof (pthread_cond_t, __data.__futex)
+-cond_nwaiters offsetof (pthread_cond_t, __data.__nwaiters)
+-total_seq offsetof (pthread_cond_t, __data.__total_seq)
+-wakeup_seq offsetof (pthread_cond_t, __data.__wakeup_seq)
+-woken_seq offsetof (pthread_cond_t, __data.__woken_seq)
+-dep_mutex offsetof (pthread_cond_t, __data.__mutex)
+-broadcast_seq offsetof (pthread_cond_t, __data.__broadcast_seq)
+-nwaiters_shift COND_NWAITERS_SHIFT
+diff --git a/nptl/nptl-printers.py b/nptl/nptl-printers.py
+index e402f23..76adadd 100644
+--- a/nptl/nptl-printers.py
++++ b/nptl/nptl-printers.py
+@@ -293,16 +293,6 @@ class MutexAttributesPrinter(object):
+ elif protocol == PTHREAD_PRIO_PROTECT:
+ self.values.append(('Protocol', 'Priority protect'))
+
+-CLOCK_IDS = {
+- CLOCK_REALTIME: 'CLOCK_REALTIME',
+- CLOCK_MONOTONIC: 'CLOCK_MONOTONIC',
+- CLOCK_PROCESS_CPUTIME_ID: 'CLOCK_PROCESS_CPUTIME_ID',
+- CLOCK_THREAD_CPUTIME_ID: 'CLOCK_THREAD_CPUTIME_ID',
+- CLOCK_MONOTONIC_RAW: 'CLOCK_MONOTONIC_RAW',
+- CLOCK_REALTIME_COARSE: 'CLOCK_REALTIME_COARSE',
+- CLOCK_MONOTONIC_COARSE: 'CLOCK_MONOTONIC_COARSE'
+-}
+-
+ class ConditionVariablePrinter(object):
+ """Pretty printer for pthread_cond_t."""
+
+@@ -313,24 +303,8 @@ class ConditionVariablePrinter(object):
+ cond: A gdb.value representing a pthread_cond_t.
+ """
+
+- # Since PTHREAD_COND_SHARED is an integer, we need to cast it to void *
+- # to be able to compare it to the condvar's __data.__mutex member.
+- #
+- # While it looks like self.shared_value should be a class variable,
+- # that would result in it having an incorrect size if we're loading
+- # these printers through .gdbinit for a 64-bit objfile in AMD64.
+- # This is because gdb initially assumes the pointer size to be 4 bytes,
+- # and only sets it to 8 after loading the 64-bit objfiles. Since
+- # .gdbinit runs before any objfiles are loaded, this would effectively
+- # make self.shared_value have a size of 4, thus breaking later
+- # comparisons with pointers whose types are looked up at runtime.
+- void_ptr_type = gdb.lookup_type('void').pointer()
+- self.shared_value = gdb.Value(PTHREAD_COND_SHARED).cast(void_ptr_type)
+-
+ data = cond['__data']
+- self.total_seq = data['__total_seq']
+- self.mutex = data['__mutex']
+- self.nwaiters = data['__nwaiters']
++ self.wrefs = data['__wrefs']
+ self.values = []
+
+ self.read_values()
+@@ -360,7 +334,6 @@ class ConditionVariablePrinter(object):
+
+ self.read_status()
+ self.read_attributes()
+- self.read_mutex_info()
+
+ def read_status(self):
+ """Read the status of the condvar.
+@@ -369,41 +342,22 @@ class ConditionVariablePrinter(object):
+ are waiting for it.
+ """
+
+- if self.total_seq == PTHREAD_COND_DESTROYED:
+- self.values.append(('Status', 'Destroyed'))
+-
+- self.values.append(('Threads waiting for this condvar',
+- self.nwaiters >> COND_NWAITERS_SHIFT))
++ self.values.append(('Threads known to still execute a wait function',
++ self.wrefs >> PTHREAD_COND_WREFS_SHIFT))
+
+ def read_attributes(self):
+ """Read the condvar's attributes."""
+
+- clock_id = self.nwaiters & ((1 << COND_NWAITERS_SHIFT) - 1)
+-
+- # clock_id must be casted to int because it's a gdb.Value
+- self.values.append(('Clock ID', CLOCK_IDS[int(clock_id)]))
++ if (self.wrefs & PTHREAD_COND_CLOCK_MONOTONIC_MASK) != 0:
++ self.values.append(('Clock ID', 'CLOCK_MONOTONIC'))
++ else:
++ self.values.append(('Clock ID', 'CLOCK_REALTIME'))
+
+- shared = (self.mutex == self.shared_value)
+-
+- if shared:
++ if (self.wrefs & PTHREAD_COND_SHARED_MASK) != 0:
+ self.values.append(('Shared', 'Yes'))
+ else:
+ self.values.append(('Shared', 'No'))
+
+- def read_mutex_info(self):
+- """Read the data of the mutex this condvar is bound to.
+-
+- A pthread_cond_t's __data.__mutex member is a void * which
+- must be casted to pthread_mutex_t *. For shared condvars, this
+- member isn't recorded and has a special value instead.
+- """
+-
+- if self.mutex and self.mutex != self.shared_value:
+- mutex_type = gdb.lookup_type('pthread_mutex_t')
+- mutex = self.mutex.cast(mutex_type.pointer()).dereference()
+-
+- self.values.append(('Mutex', mutex))
+-
+ class ConditionVariableAttributesPrinter(object):
+ """Pretty printer for pthread_condattr_t.
+
+@@ -453,10 +407,12 @@ class ConditionVariableAttributesPrinter(object):
+ created in self.children.
+ """
+
+- clock_id = self.condattr & ((1 << COND_NWAITERS_SHIFT) - 1)
++ clock_id = (self.condattr >> 1) & ((1 << COND_CLOCK_BITS) - 1)
+
+- # clock_id must be casted to int because it's a gdb.Value
+- self.values.append(('Clock ID', CLOCK_IDS[int(clock_id)]))
++ if clock_id != 0:
++ self.values.append(('Clock ID', 'CLOCK_MONOTONIC'))
++ else:
++ self.values.append(('Clock ID', 'CLOCK_REALTIME'))
+
+ if self.condattr & 1:
+ self.values.append(('Shared', 'Yes'))
+diff --git a/nptl/nptl_lock_constants.pysym b/nptl/nptl_lock_constants.pysym
+index 303ec61..2ab3179 100644
+--- a/nptl/nptl_lock_constants.pysym
++++ b/nptl/nptl_lock_constants.pysym
+@@ -44,26 +44,13 @@ PTHREAD_PRIO_NONE
+ PTHREAD_PRIO_INHERIT
+ PTHREAD_PRIO_PROTECT
+
+--- These values are hardcoded as well:
+--- Value of __mutex for shared condvars.
+-PTHREAD_COND_SHARED (void *)~0l
+-
+--- Value of __total_seq for destroyed condvars.
+-PTHREAD_COND_DESTROYED -1ull
+-
+--- __nwaiters encodes the number of threads waiting on a condvar
+--- and the clock ID.
+--- __nwaiters >> COND_NWAITERS_SHIFT gives us the number of waiters.
+-COND_NWAITERS_SHIFT
+-
+--- Condvar clock IDs
+-CLOCK_REALTIME
+-CLOCK_MONOTONIC
+-CLOCK_PROCESS_CPUTIME_ID
+-CLOCK_THREAD_CPUTIME_ID
+-CLOCK_MONOTONIC_RAW
+-CLOCK_REALTIME_COARSE
+-CLOCK_MONOTONIC_COARSE
++-- Condition variable
++-- FIXME Why do macros prefixed with __ cannot be used directly?
++PTHREAD_COND_SHARED_MASK __PTHREAD_COND_SHARED_MASK
++PTHREAD_COND_CLOCK_MONOTONIC_MASK __PTHREAD_COND_CLOCK_MONOTONIC_MASK
++COND_CLOCK_BITS
++-- These values are hardcoded:
++PTHREAD_COND_WREFS_SHIFT 3
+
+ -- Rwlock attributes
+ PTHREAD_RWLOCK_PREFER_READER_NP
+diff --git a/nptl/pthreadP.h b/nptl/pthreadP.h
+index 4edc74b..e9992bc 100644
+--- a/nptl/pthreadP.h
++++ b/nptl/pthreadP.h
+@@ -167,6 +167,13 @@ enum
+ #define __PTHREAD_ONCE_FORK_GEN_INCR 4
+
+
++/* Condition variable definitions. See __pthread_cond_wait_common.
++ Need to be defined here so there is one place from which
++ nptl_lock_constants can grab them. */
++#define __PTHREAD_COND_CLOCK_MONOTONIC_MASK 2
++#define __PTHREAD_COND_SHARED_MASK 1
++
++
+ /* Internal variables. */
+
+
+diff --git a/nptl/pthread_cond_broadcast.c b/nptl/pthread_cond_broadcast.c
+index 552fd42..87c0755 100644
+--- a/nptl/pthread_cond_broadcast.c
++++ b/nptl/pthread_cond_broadcast.c
+@@ -19,72 +19,71 @@
+ #include <endian.h>
+ #include <errno.h>
+ #include <sysdep.h>
+-#include <lowlevellock.h>
++#include <futex-internal.h>
+ #include <pthread.h>
+ #include <pthreadP.h>
+ #include <stap-probe.h>
++#include <atomic.h>
+
+ #include <shlib-compat.h>
+-#include <kernel-features.h>
+
++#include "pthread_cond_common.c"
+
++
++/* We do the following steps from __pthread_cond_signal in one critical
++ section: (1) signal all waiters in G1, (2) close G1 so that it can become
++ the new G2 and make G2 the new G1, and (3) signal all waiters in the new
++ G1. We don't need to do all these steps if there are no waiters in G1
++ and/or G2. See __pthread_cond_signal for further details. */
+ int
+ __pthread_cond_broadcast (pthread_cond_t *cond)
+ {
+ LIBC_PROBE (cond_broadcast, 1, cond);
+
+- int pshared = (cond->__data.__mutex == (void *) ~0l)
+- ? LLL_SHARED : LLL_PRIVATE;
+- /* Make sure we are alone. */
+- lll_lock (cond->__data.__lock, pshared);
++ unsigned int wrefs = atomic_load_relaxed (&cond->__data.__wrefs);
++ if (wrefs >> 3 == 0)
++ return 0;
++ int private = __condvar_get_private (wrefs);
++
++ __condvar_acquire_lock (cond, private);
+
+- /* Are there any waiters to be woken? */
+- if (cond->__data.__total_seq > cond->__data.__wakeup_seq)
++ unsigned long long int wseq = __condvar_load_wseq_relaxed (cond);
++ unsigned int g2 = wseq & 1;
++ unsigned int g1 = g2 ^ 1;
++ wseq >>= 1;
++ bool do_futex_wake = false;
++
++ /* Step (1): signal all waiters remaining in G1. */
++ if (cond->__data.__g_size[g1] != 0)
+ {
+- /* Yes. Mark them all as woken. */
+- cond->__data.__wakeup_seq = cond->__data.__total_seq;
+- cond->__data.__woken_seq = cond->__data.__total_seq;
+- cond->__data.__futex = (unsigned int) cond->__data.__total_seq * 2;
+- int futex_val = cond->__data.__futex;
+- /* Signal that a broadcast happened. */
+- ++cond->__data.__broadcast_seq;
+-
+- /* We are done. */
+- lll_unlock (cond->__data.__lock, pshared);
+-
+- /* Wake everybody. */
+- pthread_mutex_t *mut = (pthread_mutex_t *) cond->__data.__mutex;
+-
+- /* Do not use requeue for pshared condvars. */
+- if (mut == (void *) ~0l
+- || PTHREAD_MUTEX_PSHARED (mut) & PTHREAD_MUTEX_PSHARED_BIT)
+- goto wake_all;
+-
+-#if (defined lll_futex_cmp_requeue_pi \
+- && defined __ASSUME_REQUEUE_PI)
+- if (USE_REQUEUE_PI (mut))
+- {
+- if (lll_futex_cmp_requeue_pi (&cond->__data.__futex, 1, INT_MAX,
+- &mut->__data.__lock, futex_val,
+- LLL_PRIVATE) == 0)
+- return 0;
+- }
+- else
+-#endif
+- /* lll_futex_requeue returns 0 for success and non-zero
+- for errors. */
+- if (!__builtin_expect (lll_futex_requeue (&cond->__data.__futex, 1,
+- INT_MAX, &mut->__data.__lock,
+- futex_val, LLL_PRIVATE), 0))
+- return 0;
+-
+-wake_all:
+- lll_futex_wake (&cond->__data.__futex, INT_MAX, pshared);
+- return 0;
++ /* Add as many signals as the remaining size of the group. */
++ atomic_fetch_add_relaxed (cond->__data.__g_signals + g1,
++ cond->__data.__g_size[g1] << 1);
++ cond->__data.__g_size[g1] = 0;
++
++ /* We need to wake G1 waiters before we quiesce G1 below. */
++ /* TODO Only set it if there are indeed futex waiters. We could
++ also try to move this out of the critical section in cases when
++ G2 is empty (and we don't need to quiesce). */
++ futex_wake (cond->__data.__g_signals + g1, INT_MAX, private);
+ }
+
+- /* We are done. */
+- lll_unlock (cond->__data.__lock, pshared);
++ /* G1 is complete. Step (2) is next unless there are no waiters in G2, in
++ which case we can stop. */
++ if (__condvar_quiesce_and_switch_g1 (cond, wseq, &g1, private))
++ {
++ /* Step (3): Send signals to all waiters in the old G2 / new G1. */
++ atomic_fetch_add_relaxed (cond->__data.__g_signals + g1,
++ cond->__data.__g_size[g1] << 1);
++ cond->__data.__g_size[g1] = 0;
++ /* TODO Only set it if there are indeed futex waiters. */
++ do_futex_wake = true;
++ }
++
++ __condvar_release_lock (cond, private);
++
++ if (do_futex_wake)
++ futex_wake (cond->__data.__g_signals + g1, INT_MAX, private);
+
+ return 0;
+ }
+diff --git a/nptl/pthread_cond_common.c b/nptl/pthread_cond_common.c
+new file mode 100644
+index 0000000..b374396
+--- /dev/null
++++ b/nptl/pthread_cond_common.c
+@@ -0,0 +1,466 @@
++/* pthread_cond_common -- shared code for condition variable.
++ Copyright (C) 2016 Free Software Foundation, Inc.
++ This file is part of the GNU C Library.
++
++ The GNU C Library is free software; you can redistribute it and/or
++ modify it under the terms of the GNU Lesser General Public
++ License as published by the Free Software Foundation; either
++ version 2.1 of the License, or (at your option) any later version.
++
++ The GNU C Library is distributed in the hope that it will be useful,
++ but WITHOUT ANY WARRANTY; without even the implied warranty of
++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++ Lesser General Public License for more details.
++
++ You should have received a copy of the GNU Lesser General Public
++ License along with the GNU C Library; if not, see
++ <http://www.gnu.org/licenses/>. */
++
++#include <atomic.h>
++#include <stdint.h>
++#include <pthread.h>
++#include <libc-internal.h>
++
++/* We need 3 least-significant bits on __wrefs for something else. */
++#define __PTHREAD_COND_MAX_GROUP_SIZE ((unsigned) 1 << 29)
++
++#if __HAVE_64B_ATOMICS == 1
++
++static uint64_t __attribute__ ((unused))
++__condvar_load_wseq_relaxed (pthread_cond_t *cond)
++{
++ return atomic_load_relaxed (&cond->__data.__wseq);
++}
++
++static uint64_t __attribute__ ((unused))
++__condvar_fetch_add_wseq_acquire (pthread_cond_t *cond, unsigned int val)
++{
++ return atomic_fetch_add_acquire (&cond->__data.__wseq, val);
++}
++
++static uint64_t __attribute__ ((unused))
++__condvar_fetch_xor_wseq_release (pthread_cond_t *cond, unsigned int val)
++{
++ return atomic_fetch_xor_release (&cond->__data.__wseq, val);
++}
++
++static uint64_t __attribute__ ((unused))
++__condvar_load_g1_start_relaxed (pthread_cond_t *cond)
++{
++ return atomic_load_relaxed (&cond->__data.__g1_start);
++}
++
++static void __attribute__ ((unused))
++__condvar_add_g1_start_relaxed (pthread_cond_t *cond, unsigned int val)
++{
++ atomic_store_relaxed (&cond->__data.__g1_start,
++ atomic_load_relaxed (&cond->__data.__g1_start) + val);
++}
++
++#else
++
++/* We use two 64b counters: __wseq and __g1_start. They are monotonically
++ increasing and single-writer-multiple-readers counters, so we can implement
++ load, fetch-and-add, and fetch-and-xor operations even when we just have
++ 32b atomics. Values we add or xor are less than or equal to 1<<31 (*),
++ so we only have to make overflow-and-addition atomic wrt. to concurrent
++ load operations and xor operations. To do that, we split each counter into
++ two 32b values of which we reserve the MSB of each to represent an
++ overflow from the lower-order half to the higher-order half.
++
++ In the common case, the state is (higher-order / lower-order half, and . is
++ basically concatenation of the bits):
++ 0.h / 0.l = h.l
++
++ When we add a value of x that overflows (i.e., 0.l + x == 1.L), we run the
++ following steps S1-S4 (the values these represent are on the right-hand
++ side):
++ S1: 0.h / 1.L == (h+1).L
++ S2: 1.(h+1) / 1.L == (h+1).L
++ S3: 1.(h+1) / 0.L == (h+1).L
++ S4: 0.(h+1) / 0.L == (h+1).L
++ If the LSB of the higher-order half is set, readers will ignore the
++ overflow bit in the lower-order half.
++
++ To get an atomic snapshot in load operations, we exploit that the
++ higher-order half is monotonically increasing; if we load a value V from
++ it, then read the lower-order half, and then read the higher-order half
++ again and see the same value V, we know that both halves have existed in
++ the sequence of values the full counter had. This is similar to the
++ validated reads in the time-based STMs in GCC's libitm (e.g.,
++ method_ml_wt).
++
++ The xor operation needs to be an atomic read-modify-write. The write
++ itself is not an issue as it affects just the lower-order half but not bits
++ used in the add operation. To make the full fetch-and-xor atomic, we
++ exploit that concurrently, the value can increase by at most 1<<31 (*): The
++ xor operation is only called while having acquired the lock, so not more
++ than __PTHREAD_COND_MAX_GROUP_SIZE waiters can enter concurrently and thus
++ increment __wseq. Therefore, if the xor operation observes a value of
++ __wseq, then the value it applies the modification to later on can be
++ derived (see below).
++
++ One benefit of this scheme is that this makes load operations
++ obstruction-free because unlike if we would just lock the counter, readers
++ can almost always interpret a snapshot of each halves. Readers can be
++ forced to read a new snapshot when the read is concurrent with an overflow.
++ However, overflows will happen infrequently, so load operations are
++ practically lock-free.
++
++ (*) The highest value we add is __PTHREAD_COND_MAX_GROUP_SIZE << 2 to
++ __g1_start (the two extra bits are for the lock in the two LSBs of
++ __g1_start). */
++
++typedef struct
++{
++ unsigned int low;
++ unsigned int high;
++} _condvar_lohi;
++
++static uint64_t
++__condvar_fetch_add_64_relaxed (_condvar_lohi *lh, unsigned int op)
++{
++ /* S1. Note that this is an atomic read-modify-write so it extends the
++ release sequence of release MO store at S3. */
++ unsigned int l = atomic_fetch_add_relaxed (&lh->low, op);
++ unsigned int h = atomic_load_relaxed (&lh->high);
++ uint64_t result = ((uint64_t) h << 31) | l;
++ l += op;
++ if ((l >> 31) > 0)
++ {
++ /* Overflow. Need to increment higher-order half. Note that all
++ add operations are ordered in happens-before. */
++ h++;
++ /* S2. Release MO to synchronize with the loads of the higher-order half
++ in the load operation. See __condvar_load_64_relaxed. */
++ atomic_store_release (&lh->high, h | ((unsigned int) 1 << 31));
++ l ^= (unsigned int) 1 << 31;
++ /* S3. See __condvar_load_64_relaxed. */
++ atomic_store_release (&lh->low, l);
++ /* S4. Likewise. */
++ atomic_store_release (&lh->high, h);
++ }
++ return result;
++}
++
++static uint64_t
++__condvar_load_64_relaxed (_condvar_lohi *lh)
++{
++ unsigned int h, l, h2;
++ do
++ {
++ /* This load and the second one below to the same location read from the
++ stores in the overflow handling of the add operation or the
++ initializing stores (which is a simple special case because
++ initialization always completely happens before further use).
++ Because no two stores to the higher-order half write the same value,
++ the loop ensures that if we continue to use the snapshot, this load
++ and the second one read from the same store operation. All candidate
++ store operations have release MO.
++ If we read from S2 in the first load, then we will see the value of
++ S1 on the next load (because we synchronize with S2), or a value
++ later in modification order. We correctly ignore the lower-half's
++ overflow bit in this case. If we read from S4, then we will see the
++ value of S3 in the next load (or a later value), which does not have
++ the overflow bit set anymore.
++ */
++ h = atomic_load_acquire (&lh->high);
++ /* This will read from the release sequence of S3 (i.e, either the S3
++ store or the read-modify-writes at S1 following S3 in modification
++ order). Thus, the read synchronizes with S3, and the following load
++ of the higher-order half will read from the matching S2 (or a later
++ value).
++ Thus, if we read a lower-half value here that already overflowed and
++ belongs to an increased higher-order half value, we will see the
++ latter and h and h2 will not be equal. */
++ l = atomic_load_acquire (&lh->low);
++ /* See above. */
++ h2 = atomic_load_relaxed (&lh->high);
++ }
++ while (h != h2);
++ if (((l >> 31) > 0) && ((h >> 31) > 0))
++ l ^= (unsigned int) 1 << 31;
++ return ((uint64_t) (h & ~((unsigned int) 1 << 31)) << 31) + l;
++}
++
++static uint64_t __attribute__ ((unused))
++__condvar_load_wseq_relaxed (pthread_cond_t *cond)
++{
++ return __condvar_load_64_relaxed ((_condvar_lohi *) &cond->__data.__wseq32);
++}
++
++static uint64_t __attribute__ ((unused))
++__condvar_fetch_add_wseq_acquire (pthread_cond_t *cond, unsigned int val)
++{
++ uint64_t r = __condvar_fetch_add_64_relaxed
++ ((_condvar_lohi *) &cond->__data.__wseq32, val);
++ atomic_thread_fence_acquire ();
++ return r;
++}
++
++static uint64_t __attribute__ ((unused))
++__condvar_fetch_xor_wseq_release (pthread_cond_t *cond, unsigned int val)
++{
++ _condvar_lohi *lh = (_condvar_lohi *) &cond->__data.__wseq32;
++ /* First, get the current value. See __condvar_load_64_relaxed. */
++ unsigned int h, l, h2;
++ do
++ {
++ h = atomic_load_acquire (&lh->high);
++ l = atomic_load_acquire (&lh->low);
++ h2 = atomic_load_relaxed (&lh->high);
++ }
++ while (h != h2);
++ if (((l >> 31) > 0) && ((h >> 31) == 0))
++ h++;
++ h &= ~((unsigned int) 1 << 31);
++ l &= ~((unsigned int) 1 << 31);
++
++ /* Now modify. Due to the coherence rules, the prior load will read a value
++ earlier in modification order than the following fetch-xor.
++ This uses release MO to make the full operation have release semantics
++ (all other operations access the lower-order half). */
++ unsigned int l2 = atomic_fetch_xor_release (&lh->low, val)
++ & ~((unsigned int) 1 << 31);
++ if (l2 < l)
++ /* The lower-order half overflowed in the meantime. This happened exactly
++ once due to the limit on concurrent waiters (see above). */
++ h++;
++ return ((uint64_t) h << 31) + l2;
++}
++
++static uint64_t __attribute__ ((unused))
++__condvar_load_g1_start_relaxed (pthread_cond_t *cond)
++{
++ return __condvar_load_64_relaxed
++ ((_condvar_lohi *) &cond->__data.__g1_start32);
++}
++
++static void __attribute__ ((unused))
++__condvar_add_g1_start_relaxed (pthread_cond_t *cond, unsigned int val)
++{
++ ignore_value (__condvar_fetch_add_64_relaxed
++ ((_condvar_lohi *) &cond->__data.__g1_start32, val));
++}
++
++#endif /* !__HAVE_64B_ATOMICS */
++
++
++/* The lock that signalers use. See pthread_cond_wait_common for uses.
++ The lock is our normal three-state lock: not acquired (0) / acquired (1) /
++ acquired-with-futex_wake-request (2). However, we need to preserve the
++ other bits in the unsigned int used for the lock, and therefore it is a
++ little more complex. */
++static void __attribute__ ((unused))
++__condvar_acquire_lock (pthread_cond_t *cond, int private)
++{
++ unsigned int s = atomic_load_relaxed (&cond->__data.__g1_orig_size);
++ while ((s & 3) == 0)
++ {
++ if (atomic_compare_exchange_weak_acquire (&cond->__data.__g1_orig_size,
++ &s, s | 1))
++ return;
++ /* TODO Spinning and back-off. */
++ }
++ /* We can't change from not acquired to acquired, so try to change to
++ acquired-with-futex-wake-request and do a futex wait if we cannot change
++ from not acquired. */
++ while (1)
++ {
++ while ((s & 3) != 2)
++ {
++ if (atomic_compare_exchange_weak_acquire
++ (&cond->__data.__g1_orig_size, &s, (s & ~(unsigned int) 3) | 2))
++ {
++ if ((s & 3) == 0)
++ return;
++ break;
++ }
++ /* TODO Back off. */
++ }
++ futex_wait_simple (&cond->__data.__g1_orig_size,
++ (s & ~(unsigned int) 3) | 2, private);
++ /* Reload so we see a recent value. */
++ s = atomic_load_relaxed (&cond->__data.__g1_orig_size);
++ }
++}
++
++/* See __condvar_acquire_lock. */
++static void __attribute__ ((unused))
++__condvar_release_lock (pthread_cond_t *cond, int private)
++{
++ if ((atomic_fetch_and_release (&cond->__data.__g1_orig_size,
++ ~(unsigned int) 3) & 3)
++ == 2)
++ futex_wake (&cond->__data.__g1_orig_size, 1, private);
++}
++
++/* Only use this when having acquired the lock. */
++static unsigned int __attribute__ ((unused))
++__condvar_get_orig_size (pthread_cond_t *cond)
++{
++ return atomic_load_relaxed (&cond->__data.__g1_orig_size) >> 2;
++}
++
++/* Only use this when having acquired the lock. */
++static void __attribute__ ((unused))
++__condvar_set_orig_size (pthread_cond_t *cond, unsigned int size)
++{
++ /* We have acquired the lock, but might get one concurrent update due to a
++ lock state change from acquired to acquired-with-futex_wake-request.
++ The store with relaxed MO is fine because there will be no further
++ changes to the lock bits nor the size, and we will subsequently release
++ the lock with release MO. */
++ unsigned int s;
++ s = (atomic_load_relaxed (&cond->__data.__g1_orig_size) & 3)
++ | (size << 2);
++ if ((atomic_exchange_relaxed (&cond->__data.__g1_orig_size, s) & 3)
++ != (s & 3))
++ atomic_store_relaxed (&cond->__data.__g1_orig_size, (size << 2) | 2);
++}
++
++/* Returns FUTEX_SHARED or FUTEX_PRIVATE based on the provided __wrefs
++ value. */
++static int __attribute__ ((unused))
++__condvar_get_private (int flags)
++{
++ if ((flags & __PTHREAD_COND_SHARED_MASK) == 0)
++ return FUTEX_PRIVATE;
++ else
++ return FUTEX_SHARED;
++}
++
++/* This closes G1 (whose index is in G1INDEX), waits for all futex waiters to
++ leave G1, converts G1 into a fresh G2, and then switches group roles so that
++ the former G2 becomes the new G1 ending at the current __wseq value when we
++ eventually make the switch (WSEQ is just an observation of __wseq by the
++ signaler).
++ If G2 is empty, it will not switch groups because then it would create an
++ empty G1 which would require switching groups again on the next signal.
++ Returns false iff groups were not switched because G2 was empty. */
++static bool __attribute__ ((unused))
++__condvar_quiesce_and_switch_g1 (pthread_cond_t *cond, uint64_t wseq,
++ unsigned int *g1index, int private)
++{
++ const unsigned int maxspin = 0;
++ unsigned int g1 = *g1index;
++
++ /* If there is no waiter in G2, we don't do anything. The expression may
++ look odd but remember that __g_size might hold a negative value, so
++ putting the expression this way avoids relying on implementation-defined
++ behavior.
++ Note that this works correctly for a zero-initialized condvar too. */
++ unsigned int old_orig_size = __condvar_get_orig_size (cond);
++ uint64_t old_g1_start = __condvar_load_g1_start_relaxed (cond) >> 1;
++ if (((unsigned) (wseq - old_g1_start - old_orig_size)
++ + cond->__data.__g_size[g1 ^ 1]) == 0)
++ return false;
++
++ /* Now try to close and quiesce G1. We have to consider the following kinds
++ of waiters:
++ * Waiters from less recent groups than G1 are not affected because
++ nothing will change for them apart from __g1_start getting larger.
++ * New waiters arriving concurrently with the group switching will all go
++ into G2 until we atomically make the switch. Waiters existing in G2
++ are not affected.
++ * Waiters in G1 will be closed out immediately by setting a flag in
++ __g_signals, which will prevent waiters from blocking using a futex on
++ __g_signals and also notifies them that the group is closed. As a
++ result, they will eventually remove their group reference, allowing us
++ to close switch group roles. */
++
++ /* First, set the closed flag on __g_signals. This tells waiters that are
++ about to wait that they shouldn't do that anymore. This basically
++ serves as an advance notificaton of the upcoming change to __g1_start;
++ waiters interpret it as if __g1_start was larger than their waiter
++ sequence position. This allows us to change __g1_start after waiting
++ for all existing waiters with group references to leave, which in turn
++ makes recovery after stealing a signal simpler because it then can be
++ skipped if __g1_start indicates that the group is closed (otherwise,
++ we would have to recover always because waiters don't know how big their
++ groups are). Relaxed MO is fine. */
++ atomic_fetch_or_relaxed (cond->__data.__g_signals + g1, 1);
++
++ /* Wait until there are no group references anymore. The fetch-or operation
++ injects us into the modification order of __g_refs; release MO ensures
++ that waiters incrementing __g_refs after our fetch-or see the previous
++ changes to __g_signals and to __g1_start that had to happen before we can
++ switch this G1 and alias with an older group (we have two groups, so
++ aliasing requires switching group roles twice). Note that nobody else
++ can have set the wake-request flag, so we do not have to act upon it.
++
++ Also note that it is harmless if older waiters or waiters from this G1
++ get a group reference after we have quiesced the group because it will
++ remain closed for them either because of the closed flag in __g_signals
++ or the later update to __g1_start. New waiters will never arrive here
++ but instead continue to go into the still current G2. */
++ unsigned r = atomic_fetch_or_release (cond->__data.__g_refs + g1, 0);
++ while ((r >> 1) > 0)
++ {
++ for (unsigned int spin = maxspin; ((r >> 1) > 0) && (spin > 0); spin--)
++ {
++ /* TODO Back off. */
++ r = atomic_load_relaxed (cond->__data.__g_refs + g1);
++ }
++ if ((r >> 1) > 0)
++ {
++ /* There is still a waiter after spinning. Set the wake-request
++ flag and block. Relaxed MO is fine because this is just about
++ this futex word. */
++ r = atomic_fetch_or_relaxed (cond->__data.__g_refs + g1, 1);
++
++ if ((r >> 1) > 0)
++ futex_wait_simple (cond->__data.__g_refs + g1, r, private);
++ /* Reload here so we eventually see the most recent value even if we
++ do not spin. */
++ r = atomic_load_relaxed (cond->__data.__g_refs + g1);
++ }
++ }
++ /* Acquire MO so that we synchronize with the release operation that waiters
++ use to decrement __g_refs and thus happen after the waiters we waited
++ for. */
++ atomic_thread_fence_acquire ();
++
++ /* Update __g1_start, which finishes closing this group. The value we add
++ will never be negative because old_orig_size can only be zero when we
++ switch groups the first time after a condvar was initialized, in which
++ case G1 will be at index 1 and we will add a value of 1. See above for
++ why this takes place after waiting for quiescence of the group.
++ Relaxed MO is fine because the change comes with no additional
++ constraints that others would have to observe. */
++ __condvar_add_g1_start_relaxed (cond,
++ (old_orig_size << 1) + (g1 == 1 ? 1 : - 1));
++
++ /* Now reopen the group, thus enabling waiters to again block using the
++ futex controlled by __g_signals. Release MO so that observers that see
++ no signals (and thus can block) also see the write __g1_start and thus
++ that this is now a new group (see __pthread_cond_wait_common for the
++ matching acquire MO loads). */
++ atomic_store_release (cond->__data.__g_signals + g1, 0);
++
++ /* At this point, the old G1 is now a valid new G2 (but not in use yet).
++ No old waiter can neither grab a signal nor acquire a reference without
++ noticing that __g1_start is larger.
++ We can now publish the group switch by flipping the G2 index in __wseq.
++ Release MO so that this synchronizes with the acquire MO operation
++ waiters use to obtain a position in the waiter sequence. */
++ wseq = __condvar_fetch_xor_wseq_release (cond, 1) >> 1;
++ g1 ^= 1;
++ *g1index ^= 1;
++
++ /* These values are just observed by signalers, and thus protected by the
++ lock. */
++ unsigned int orig_size = wseq - (old_g1_start + old_orig_size);
++ __condvar_set_orig_size (cond, orig_size);
++ /* Use and addition to not loose track of cancellations in what was
++ previously G2. */
++ cond->__data.__g_size[g1] += orig_size;
++
++ /* The new G1's size may be zero because of cancellations during its time
++ as G2. If this happens, there are no waiters that have to receive a
++ signal, so we do not need to add any and return false. */
++ if (cond->__data.__g_size[g1] == 0)
++ return false;
++
++ return true;
++}
+diff --git a/nptl/pthread_cond_destroy.c b/nptl/pthread_cond_destroy.c
+index 1acd804..5845c6a 100644
+--- a/nptl/pthread_cond_destroy.c
++++ b/nptl/pthread_cond_destroy.c
+@@ -20,66 +20,42 @@
+ #include <shlib-compat.h>
+ #include "pthreadP.h"
+ #include <stap-probe.h>
+-
+-
++#include <atomic.h>
++#include <futex-internal.h>
++
++#include "pthread_cond_common.c"
++
++/* See __pthread_cond_wait for a high-level description of the algorithm.
++
++ A correct program must make sure that no waiters are blocked on the condvar
++ when it is destroyed, and that there are no concurrent signals or
++ broadcasts. To wake waiters reliably, the program must signal or
++ broadcast while holding the mutex or after having held the mutex. It must
++ also ensure that no signal or broadcast are still pending to unblock
++ waiters; IOW, because waiters can wake up spuriously, the program must
++ effectively ensure that destruction happens after the execution of those
++ signal or broadcast calls.
++ Thus, we can assume that all waiters that are still accessing the condvar
++ have been woken. We wait until they have confirmed to have woken up by
++ decrementing __wrefs. */
+ int
+ __pthread_cond_destroy (pthread_cond_t *cond)
+ {
+- int pshared = (cond->__data.__mutex == (void *) ~0l)
+- ? LLL_SHARED : LLL_PRIVATE;
+-
+ LIBC_PROBE (cond_destroy, 1, cond);
+
+- /* Make sure we are alone. */
+- lll_lock (cond->__data.__lock, pshared);
+-
+- if (cond->__data.__total_seq > cond->__data.__wakeup_seq)
+- {
+- /* If there are still some waiters which have not been
+- woken up, this is an application bug. */
+- lll_unlock (cond->__data.__lock, pshared);
+- return EBUSY;
+- }
+-
+- /* Tell pthread_cond_*wait that this condvar is being destroyed. */
+- cond->__data.__total_seq = -1ULL;
+-
+- /* If there are waiters which have been already signalled or
+- broadcasted, but still are using the pthread_cond_t structure,
+- pthread_cond_destroy needs to wait for them. */
+- unsigned int nwaiters = cond->__data.__nwaiters;
+-
+- if (nwaiters >= (1 << COND_NWAITERS_SHIFT))
++ /* Set the wake request flag. We could also spin, but destruction that is
++ concurrent with still-active waiters is probably neither common nor
++ performance critical. Acquire MO to synchronize with waiters confirming
++ that they finished. */
++ unsigned int wrefs = atomic_fetch_or_acquire (&cond->__data.__wrefs, 4);
++ int private = __condvar_get_private (wrefs);
++ while (wrefs >> 3 != 0)
+ {
+- /* Wake everybody on the associated mutex in case there are
+- threads that have been requeued to it.
+- Without this, pthread_cond_destroy could block potentially
+- for a long time or forever, as it would depend on other
+- thread's using the mutex.
+- When all threads waiting on the mutex are woken up, pthread_cond_wait
+- only waits for threads to acquire and release the internal
+- condvar lock. */
+- if (cond->__data.__mutex != NULL
+- && cond->__data.__mutex != (void *) ~0l)
+- {
+- pthread_mutex_t *mut = (pthread_mutex_t *) cond->__data.__mutex;
+- lll_futex_wake (&mut->__data.__lock, INT_MAX,
+- PTHREAD_MUTEX_PSHARED (mut));
+- }
+-
+- do
+- {
+- lll_unlock (cond->__data.__lock, pshared);
+-
+- lll_futex_wait (&cond->__data.__nwaiters, nwaiters, pshared);
+-
+- lll_lock (cond->__data.__lock, pshared);
+-
+- nwaiters = cond->__data.__nwaiters;
+- }
+- while (nwaiters >= (1 << COND_NWAITERS_SHIFT));
++ futex_wait_simple (&cond->__data.__wrefs, wrefs, private);
++ /* See above. */
++ wrefs = atomic_load_acquire (&cond->__data.__wrefs);
+ }
+-
++ /* The memory the condvar occupies can now be reused. */
+ return 0;
+ }
+ versioned_symbol (libpthread, __pthread_cond_destroy,
+diff --git a/nptl/pthread_cond_init.c b/nptl/pthread_cond_init.c
+index 9023370..c1eac5f 100644
+--- a/nptl/pthread_cond_init.c
++++ b/nptl/pthread_cond_init.c
+@@ -19,25 +19,29 @@
+ #include <shlib-compat.h>
+ #include "pthreadP.h"
+ #include <stap-probe.h>
++#include <string.h>
+
+
++/* See __pthread_cond_wait for details. */
+ int
+ __pthread_cond_init (pthread_cond_t *cond, const pthread_condattr_t *cond_attr)
+ {
+ struct pthread_condattr *icond_attr = (struct pthread_condattr *) cond_attr;
+
+- cond->__data.__lock = LLL_LOCK_INITIALIZER;
+- cond->__data.__futex = 0;
+- cond->__data.__nwaiters = (icond_attr != NULL
+- ? ((icond_attr->value >> 1)
+- & ((1 << COND_NWAITERS_SHIFT) - 1))
+- : CLOCK_REALTIME);
+- cond->__data.__total_seq = 0;
+- cond->__data.__wakeup_seq = 0;
+- cond->__data.__woken_seq = 0;
+- cond->__data.__mutex = (icond_attr == NULL || (icond_attr->value & 1) == 0
+- ? NULL : (void *) ~0l);
+- cond->__data.__broadcast_seq = 0;
++ memset (cond, 0, sizeof (pthread_cond_t));
++
++ /* Update the pretty printers if the internal representation of icond_attr
++ is changed. */
++
++ /* Iff not equal to ~0l, this is a PTHREAD_PROCESS_PRIVATE condvar. */
++ if (icond_attr != NULL && (icond_attr->value & 1) != 0)
++ cond->__data.__wrefs |= __PTHREAD_COND_SHARED_MASK;
++ int clockid = (icond_attr != NULL
++ ? ((icond_attr->value >> 1) & ((1 << COND_CLOCK_BITS) - 1))
++ : CLOCK_REALTIME);
++ /* If 0, CLOCK_REALTIME is used; CLOCK_MONOTONIC otherwise. */
++ if (clockid != CLOCK_REALTIME)
++ cond->__data.__wrefs |= __PTHREAD_COND_CLOCK_MONOTONIC_MASK;
+
+ LIBC_PROBE (cond_init, 2, cond, cond_attr);
+
+diff --git a/nptl/pthread_cond_signal.c b/nptl/pthread_cond_signal.c
+index b3a6d3d..a95d569 100644
+--- a/nptl/pthread_cond_signal.c
++++ b/nptl/pthread_cond_signal.c
+@@ -19,62 +19,79 @@
+ #include <endian.h>
+ #include <errno.h>
+ #include <sysdep.h>
+-#include <lowlevellock.h>
++#include <futex-internal.h>
+ #include <pthread.h>
+ #include <pthreadP.h>
++#include <atomic.h>
++#include <stdint.h>
+
+ #include <shlib-compat.h>
+-#include <kernel-features.h>
+ #include <stap-probe.h>
+
++#include "pthread_cond_common.c"
+
++/* See __pthread_cond_wait for a high-level description of the algorithm. */
+ int
+ __pthread_cond_signal (pthread_cond_t *cond)
+ {
+- int pshared = (cond->__data.__mutex == (void *) ~0l)
+- ? LLL_SHARED : LLL_PRIVATE;
+-
+ LIBC_PROBE (cond_signal, 1, cond);
+
+- /* Make sure we are alone. */
+- lll_lock (cond->__data.__lock, pshared);
+-
+- /* Are there any waiters to be woken? */
+- if (cond->__data.__total_seq > cond->__data.__wakeup_seq)
++ /* First check whether there are waiters. Relaxed MO is fine for that for
++ the same reasons that relaxed MO is fine when observing __wseq (see
++ below). */
++ unsigned int wrefs = atomic_load_relaxed (&cond->__data.__wrefs);
++ if (wrefs >> 3 == 0)
++ return 0;
++ int private = __condvar_get_private (wrefs);
++
++ __condvar_acquire_lock (cond, private);
++
++ /* Load the waiter sequence number, which represents our relative ordering
++ to any waiters. Relaxed MO is sufficient for that because:
++ 1) We can pick any position that is allowed by external happens-before
++ constraints. In particular, if another __pthread_cond_wait call
++ happened before us, this waiter must be eligible for being woken by
++ us. The only way do establish such a happens-before is by signaling
++ while having acquired the mutex associated with the condvar and
++ ensuring that the signal's critical section happens after the waiter.
++ Thus, the mutex ensures that we see that waiter's __wseq increase.
++ 2) Once we pick a position, we do not need to communicate this to the
++ program via a happens-before that we set up: First, any wake-up could
++ be a spurious wake-up, so the program must not interpret a wake-up as
++ an indication that the waiter happened before a particular signal;
++ second, a program cannot detect whether a waiter has not yet been
++ woken (i.e., it cannot distinguish between a non-woken waiter and one
++ that has been woken but hasn't resumed execution yet), and thus it
++ cannot try to deduce that a signal happened before a particular
++ waiter. */
++ unsigned long long int wseq = __condvar_load_wseq_relaxed (cond);
++ unsigned int g1 = (wseq & 1) ^ 1;
++ wseq >>= 1;
++ bool do_futex_wake = false;
++
++ /* If G1 is still receiving signals, we put the signal there. If not, we
++ check if G2 has waiters, and if so, quiesce and switch G1 to the former
++ G2; if this results in a new G1 with waiters (G2 might have cancellations
++ already, see __condvar_quiesce_and_switch_g1), we put the signal in the
++ new G1. */
++ if ((cond->__data.__g_size[g1] != 0)
++ || __condvar_quiesce_and_switch_g1 (cond, wseq, &g1, private))
+ {
+- /* Yes. Mark one of them as woken. */
+- ++cond->__data.__wakeup_seq;
+- ++cond->__data.__futex;
+-
+-#if (defined lll_futex_cmp_requeue_pi \
+- && defined __ASSUME_REQUEUE_PI)
+- pthread_mutex_t *mut = cond->__data.__mutex;
+-
+- if (USE_REQUEUE_PI (mut)
+- /* This can only really fail with a ENOSYS, since nobody can modify
+- futex while we have the cond_lock. */
+- && lll_futex_cmp_requeue_pi (&cond->__data.__futex, 1, 0,
+- &mut->__data.__lock,
+- cond->__data.__futex, pshared) == 0)
+- {
+- lll_unlock (cond->__data.__lock, pshared);
+- return 0;
+- }
+- else
+-#endif
+- /* Wake one. */
+- if (! __builtin_expect (lll_futex_wake_unlock (&cond->__data.__futex,
+- 1, 1,
+- &cond->__data.__lock,
+- pshared), 0))
+- return 0;
+-
+- /* Fallback if neither of them work. */
+- lll_futex_wake (&cond->__data.__futex, 1, pshared);
++ /* Add a signal. Relaxed MO is fine because signaling does not need to
++ establish a happens-before relation (see above). We do not mask the
++ release-MO store when initializing a group in
++ __condvar_quiesce_and_switch_g1 because we use an atomic
++ read-modify-write and thus extend that store's release sequence. */
++ atomic_fetch_add_relaxed (cond->__data.__g_signals + g1, 2);
++ cond->__data.__g_size[g1]--;
++ /* TODO Only set it if there are indeed futex waiters. */
++ do_futex_wake = true;
+ }
+
+- /* We are done. */
+- lll_unlock (cond->__data.__lock, pshared);
++ __condvar_release_lock (cond, private);
++
++ if (do_futex_wake)
++ futex_wake (cond->__data.__g_signals + g1, 1, private);
+
+ return 0;
+ }
+diff --git a/nptl/pthread_cond_timedwait.c b/nptl/pthread_cond_timedwait.c
+deleted file mode 100644
+index 711a51d..0000000
+--- a/nptl/pthread_cond_timedwait.c
++++ /dev/null
+@@ -1,268 +0,0 @@
+-/* Copyright (C) 2003-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Martin Schwidefsky <schwidefsky at de.ibm.com>, 2003.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library; if not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#include <endian.h>
+-#include <errno.h>
+-#include <sysdep.h>
+-#include <lowlevellock.h>
+-#include <pthread.h>
+-#include <pthreadP.h>
+-#include <sys/time.h>
+-#include <kernel-features.h>
+-
+-#include <shlib-compat.h>
+-
+-#ifndef HAVE_CLOCK_GETTIME_VSYSCALL
+-# undef INTERNAL_VSYSCALL
+-# define INTERNAL_VSYSCALL INTERNAL_SYSCALL
+-# undef INLINE_VSYSCALL
+-# define INLINE_VSYSCALL INLINE_SYSCALL
+-#else
+-# include <libc-vdso.h>
+-#endif
+-
+-/* Cleanup handler, defined in pthread_cond_wait.c. */
+-extern void __condvar_cleanup (void *arg)
+- __attribute__ ((visibility ("hidden")));
+-
+-struct _condvar_cleanup_buffer
+-{
+- int oldtype;
+- pthread_cond_t *cond;
+- pthread_mutex_t *mutex;
+- unsigned int bc_seq;
+-};
+-
+-int
+-__pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex,
+- const struct timespec *abstime)
+-{
+- struct _pthread_cleanup_buffer buffer;
+- struct _condvar_cleanup_buffer cbuffer;
+- int result = 0;
+-
+- /* Catch invalid parameters. */
+- if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
+- return EINVAL;
+-
+- int pshared = (cond->__data.__mutex == (void *) ~0l)
+- ? LLL_SHARED : LLL_PRIVATE;
+-
+-#if (defined lll_futex_timed_wait_requeue_pi \
+- && defined __ASSUME_REQUEUE_PI)
+- int pi_flag = 0;
+-#endif
+-
+- /* Make sure we are alone. */
+- lll_lock (cond->__data.__lock, pshared);
+-
+- /* Now we can release the mutex. */
+- int err = __pthread_mutex_unlock_usercnt (mutex, 0);
+- if (err)
+- {
+- lll_unlock (cond->__data.__lock, pshared);
+- return err;
+- }
+-
+- /* We have one new user of the condvar. */
+- ++cond->__data.__total_seq;
+- ++cond->__data.__futex;
+- cond->__data.__nwaiters += 1 << COND_NWAITERS_SHIFT;
+-
+- /* Work around the fact that the kernel rejects negative timeout values
+- despite them being valid. */
+- if (__glibc_unlikely (abstime->tv_sec < 0))
+- goto timeout;
+-
+- /* Remember the mutex we are using here. If there is already a
+- different address store this is a bad user bug. Do not store
+- anything for pshared condvars. */
+- if (cond->__data.__mutex != (void *) ~0l)
+- cond->__data.__mutex = mutex;
+-
+- /* Prepare structure passed to cancellation handler. */
+- cbuffer.cond = cond;
+- cbuffer.mutex = mutex;
+-
+- /* Before we block we enable cancellation. Therefore we have to
+- install a cancellation handler. */
+- __pthread_cleanup_push (&buffer, __condvar_cleanup, &cbuffer);
+-
+- /* The current values of the wakeup counter. The "woken" counter
+- must exceed this value. */
+- unsigned long long int val;
+- unsigned long long int seq;
+- val = seq = cond->__data.__wakeup_seq;
+- /* Remember the broadcast counter. */
+- cbuffer.bc_seq = cond->__data.__broadcast_seq;
+-
+- while (1)
+- {
+-#if (!defined __ASSUME_FUTEX_CLOCK_REALTIME \
+- || !defined lll_futex_timed_wait_bitset)
+- struct timespec rt;
+- {
+-# ifdef __NR_clock_gettime
+- INTERNAL_SYSCALL_DECL (err);
+- (void) INTERNAL_VSYSCALL (clock_gettime, err, 2,
+- (cond->__data.__nwaiters
+- & ((1 << COND_NWAITERS_SHIFT) - 1)),
+- &rt);
+- /* Convert the absolute timeout value to a relative timeout. */
+- rt.tv_sec = abstime->tv_sec - rt.tv_sec;
+- rt.tv_nsec = abstime->tv_nsec - rt.tv_nsec;
+-# else
+- /* Get the current time. So far we support only one clock. */
+- struct timeval tv;
+- (void) __gettimeofday (&tv, NULL);
+-
+- /* Convert the absolute timeout value to a relative timeout. */
+- rt.tv_sec = abstime->tv_sec - tv.tv_sec;
+- rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
+-# endif
+- }
+- if (rt.tv_nsec < 0)
+- {
+- rt.tv_nsec += 1000000000;
+- --rt.tv_sec;
+- }
+- /* Did we already time out? */
+- if (__glibc_unlikely (rt.tv_sec < 0))
+- {
+- if (cbuffer.bc_seq != cond->__data.__broadcast_seq)
+- goto bc_out;
+-
+- goto timeout;
+- }
+-#endif
+-
+- unsigned int futex_val = cond->__data.__futex;
+-
+- /* Prepare to wait. Release the condvar futex. */
+- lll_unlock (cond->__data.__lock, pshared);
+-
+- /* Enable asynchronous cancellation. Required by the standard. */
+- cbuffer.oldtype = __pthread_enable_asynccancel ();
+-
+-/* REQUEUE_PI was implemented after FUTEX_CLOCK_REALTIME, so it is sufficient
+- to check just the former. */
+-#if (defined lll_futex_timed_wait_requeue_pi \
+- && defined __ASSUME_REQUEUE_PI)
+- /* If pi_flag remained 1 then it means that we had the lock and the mutex
+- but a spurious waker raced ahead of us. Give back the mutex before
+- going into wait again. */
+- if (pi_flag)
+- {
+- __pthread_mutex_cond_lock_adjust (mutex);
+- __pthread_mutex_unlock_usercnt (mutex, 0);
+- }
+- pi_flag = USE_REQUEUE_PI (mutex);
+-
+- if (pi_flag)
+- {
+- unsigned int clockbit = (cond->__data.__nwaiters & 1
+- ? 0 : FUTEX_CLOCK_REALTIME);
+- err = lll_futex_timed_wait_requeue_pi (&cond->__data.__futex,
+- futex_val, abstime, clockbit,
+- &mutex->__data.__lock,
+- pshared);
+- pi_flag = (err == 0);
+- }
+- else
+-#endif
+-
+- {
+-#if (!defined __ASSUME_FUTEX_CLOCK_REALTIME \
+- || !defined lll_futex_timed_wait_bitset)
+- /* Wait until woken by signal or broadcast. */
+- err = lll_futex_timed_wait (&cond->__data.__futex,
+- futex_val, &rt, pshared);
+-#else
+- unsigned int clockbit = (cond->__data.__nwaiters & 1
+- ? 0 : FUTEX_CLOCK_REALTIME);
+- err = lll_futex_timed_wait_bitset (&cond->__data.__futex, futex_val,
+- abstime, clockbit, pshared);
+-#endif
+- }
+-
+- /* Disable asynchronous cancellation. */
+- __pthread_disable_asynccancel (cbuffer.oldtype);
+-
+- /* We are going to look at shared data again, so get the lock. */
+- lll_lock (cond->__data.__lock, pshared);
+-
+- /* If a broadcast happened, we are done. */
+- if (cbuffer.bc_seq != cond->__data.__broadcast_seq)
+- goto bc_out;
+-
+- /* Check whether we are eligible for wakeup. */
+- val = cond->__data.__wakeup_seq;
+- if (val != seq && cond->__data.__woken_seq != val)
+- break;
+-
+- /* Not woken yet. Maybe the time expired? */
+- if (__glibc_unlikely (err == -ETIMEDOUT))
+- {
+- timeout:
+- /* Yep. Adjust the counters. */
+- ++cond->__data.__wakeup_seq;
+- ++cond->__data.__futex;
+-
+- /* The error value. */
+- result = ETIMEDOUT;
+- break;
+- }
+- }
+-
+- /* Another thread woken up. */
+- ++cond->__data.__woken_seq;
+-
+- bc_out:
+-
+- cond->__data.__nwaiters -= 1 << COND_NWAITERS_SHIFT;
+-
+- /* If pthread_cond_destroy was called on this variable already,
+- notify the pthread_cond_destroy caller all waiters have left
+- and it can be successfully destroyed. */
+- if (cond->__data.__total_seq == -1ULL
+- && cond->__data.__nwaiters < (1 << COND_NWAITERS_SHIFT))
+- lll_futex_wake (&cond->__data.__nwaiters, 1, pshared);
+-
+- /* We are done with the condvar. */
+- lll_unlock (cond->__data.__lock, pshared);
+-
+- /* The cancellation handling is back to normal, remove the handler. */
+- __pthread_cleanup_pop (&buffer, 0);
+-
+- /* Get the mutex before returning. */
+-#if (defined lll_futex_timed_wait_requeue_pi \
+- && defined __ASSUME_REQUEUE_PI)
+- if (pi_flag)
+- {
+- __pthread_mutex_cond_lock_adjust (mutex);
+- err = 0;
+- }
+- else
+-#endif
+- err = __pthread_mutex_cond_lock (mutex);
+-
+- return err ?: result;
+-}
+-
+-versioned_symbol (libpthread, __pthread_cond_timedwait, pthread_cond_timedwait,
+- GLIBC_2_3_2);
+diff --git a/nptl/pthread_cond_wait.c b/nptl/pthread_cond_wait.c
+index 3f62acc..2b43402 100644
+--- a/nptl/pthread_cond_wait.c
++++ b/nptl/pthread_cond_wait.c
+@@ -19,219 +19,655 @@
+ #include <endian.h>
+ #include <errno.h>
+ #include <sysdep.h>
+-#include <lowlevellock.h>
++#include <futex-internal.h>
+ #include <pthread.h>
+ #include <pthreadP.h>
+-#include <kernel-features.h>
++#include <sys/time.h>
++#include <atomic.h>
++#include <stdint.h>
++#include <stdbool.h>
+
+ #include <shlib-compat.h>
+ #include <stap-probe.h>
++#include <time.h>
++
++#include "pthread_cond_common.c"
++
+
+ struct _condvar_cleanup_buffer
+ {
+- int oldtype;
++ uint64_t wseq;
+ pthread_cond_t *cond;
+ pthread_mutex_t *mutex;
+- unsigned int bc_seq;
++ int private;
+ };
+
+
+-void
+-__attribute__ ((visibility ("hidden")))
+-__condvar_cleanup (void *arg)
++/* Decrease the waiter reference count. */
++static void
++__condvar_confirm_wakeup (pthread_cond_t *cond, int private)
+ {
+- struct _condvar_cleanup_buffer *cbuffer =
+- (struct _condvar_cleanup_buffer *) arg;
+- unsigned int destroying;
+- int pshared = (cbuffer->cond->__data.__mutex == (void *) ~0l)
+- ? LLL_SHARED : LLL_PRIVATE;
++ /* If destruction is pending (i.e., the wake-request flag is nonzero) and we
++ are the last waiter (prior value of __wrefs was 1 << 3), then wake any
++ threads waiting in pthread_cond_destroy. Release MO to synchronize with
++ these threads. Don't bother clearing the wake-up request flag. */
++ if ((atomic_fetch_add_release (&cond->__data.__wrefs, -8) >> 2) == 3)
++ futex_wake (&cond->__data.__wrefs, INT_MAX, private);
++}
++
+
+- /* We are going to modify shared data. */
+- lll_lock (cbuffer->cond->__data.__lock, pshared);
++/* Cancel waiting after having registered as a waiter previously. SEQ is our
++ position and G is our group index.
++ The goal of cancellation is to make our group smaller if that is still
++ possible. If we are in a closed group, this is not possible anymore; in
++ this case, we need to send a replacement signal for the one we effectively
++ consumed because the signal should have gotten consumed by another waiter
++ instead; we must not both cancel waiting and consume a signal.
++
++ Must not be called while still holding a reference on the group.
++
++ Returns true iff we consumed a signal.
++
++ On some kind of timeouts, we may be able to pretend that a signal we
++ effectively consumed happened before the timeout (i.e., similarly to first
++ spinning on signals before actually checking whether the timeout has
++ passed already). Doing this would allow us to skip sending a replacement
++ signal, but this case might happen rarely because the end of the timeout
++ must race with someone else sending a signal. Therefore, we don't bother
++ trying to optimize this. */
++static void
++__condvar_cancel_waiting (pthread_cond_t *cond, uint64_t seq, unsigned int g,
++ int private)
++{
++ bool consumed_signal = false;
+
+- if (cbuffer->bc_seq == cbuffer->cond->__data.__broadcast_seq)
++ /* No deadlock with group switching is possible here because we have do
++ not hold a reference on the group. */
++ __condvar_acquire_lock (cond, private);
++
++ uint64_t g1_start = __condvar_load_g1_start_relaxed (cond) >> 1;
++ if (g1_start > seq)
++ {
++ /* Our group is closed, so someone provided enough signals for it.
++ Thus, we effectively consumed a signal. */
++ consumed_signal = true;
++ }
++ else
+ {
+- /* This thread is not waiting anymore. Adjust the sequence counters
+- appropriately. We do not increment WAKEUP_SEQ if this would
+- bump it over the value of TOTAL_SEQ. This can happen if a thread
+- was woken and then canceled. */
+- if (cbuffer->cond->__data.__wakeup_seq
+- < cbuffer->cond->__data.__total_seq)
++ if (g1_start + __condvar_get_orig_size (cond) <= seq)
++ {
++ /* We are in the current G2 and thus cannot have consumed a signal.
++ Reduce its effective size or handle overflow. Remember that in
++ G2, unsigned int size is zero or a negative value. */
++ if (cond->__data.__g_size[g] + __PTHREAD_COND_MAX_GROUP_SIZE > 0)
++ {
++ cond->__data.__g_size[g]--;
++ }
++ else
++ {
++ /* Cancellations would overflow the maximum group size. Just
++ wake up everyone spuriously to create a clean state. This
++ also means we do not consume a signal someone else sent. */
++ __condvar_release_lock (cond, private);
++ __pthread_cond_broadcast (cond);
++ return;
++ }
++ }
++ else
+ {
+- ++cbuffer->cond->__data.__wakeup_seq;
+- ++cbuffer->cond->__data.__futex;
++ /* We are in current G1. If the group's size is zero, someone put
++ a signal in the group that nobody else but us can consume. */
++ if (cond->__data.__g_size[g] == 0)
++ consumed_signal = true;
++ else
++ {
++ /* Otherwise, we decrease the size of the group. This is
++ equivalent to atomically putting in a signal just for us and
++ consuming it right away. We do not consume a signal sent
++ by someone else. We also cannot have consumed a futex
++ wake-up because if we were cancelled or timed out in a futex
++ call, the futex will wake another waiter. */
++ cond->__data.__g_size[g]--;
++ }
+ }
+- ++cbuffer->cond->__data.__woken_seq;
+ }
+
+- cbuffer->cond->__data.__nwaiters -= 1 << COND_NWAITERS_SHIFT;
++ __condvar_release_lock (cond, private);
+
+- /* If pthread_cond_destroy was called on this variable already,
+- notify the pthread_cond_destroy caller all waiters have left
+- and it can be successfully destroyed. */
+- destroying = 0;
+- if (cbuffer->cond->__data.__total_seq == -1ULL
+- && cbuffer->cond->__data.__nwaiters < (1 << COND_NWAITERS_SHIFT))
++ if (consumed_signal)
+ {
+- lll_futex_wake (&cbuffer->cond->__data.__nwaiters, 1, pshared);
+- destroying = 1;
++ /* We effectively consumed a signal even though we didn't want to.
++ Therefore, we need to send a replacement signal.
++ If we would want to optimize this, we could do what
++ pthread_cond_signal does right in the critical section above. */
++ __pthread_cond_signal (cond);
+ }
++}
+
+- /* We are done. */
+- lll_unlock (cbuffer->cond->__data.__lock, pshared);
+-
+- /* Wake everybody to make sure no condvar signal gets lost. */
+- if (! destroying)
+- lll_futex_wake (&cbuffer->cond->__data.__futex, INT_MAX, pshared);
+-
+- /* Get the mutex before returning unless asynchronous cancellation
+- is in effect. We don't try to get the mutex if we already own it. */
+- if (!(USE_REQUEUE_PI (cbuffer->mutex))
+- || ((cbuffer->mutex->__data.__lock & FUTEX_TID_MASK)
+- != THREAD_GETMEM (THREAD_SELF, tid)))
+- {
+- __pthread_mutex_cond_lock (cbuffer->mutex);
+- }
+- else
+- __pthread_mutex_cond_lock_adjust (cbuffer->mutex);
++/* Wake up any signalers that might be waiting. */
++static void
++__condvar_dec_grefs (pthread_cond_t *cond, unsigned int g, int private)
++{
++ /* Release MO to synchronize-with the acquire load in
++ __condvar_quiesce_and_switch_g1. */
++ if (atomic_fetch_add_release (cond->__data.__g_refs + g, -2) == 3)
++ {
++ /* Clear the wake-up request flag before waking up. We do not need more
++ than relaxed MO and it doesn't matter if we apply this for an aliased
++ group because we wake all futex waiters right after clearing the
++ flag. */
++ atomic_fetch_and_relaxed (cond->__data.__g_refs + g, ~(unsigned int) 1);
++ futex_wake (cond->__data.__g_refs + g, INT_MAX, private);
++ }
+ }
+
++/* Clean-up for cancellation of waiters waiting for normal signals. We cancel
++ our registration as a waiter, confirm we have woken up, and re-acquire the
++ mutex. */
++static void
++__condvar_cleanup_waiting (void *arg)
++{
++ struct _condvar_cleanup_buffer *cbuffer =
++ (struct _condvar_cleanup_buffer *) arg;
++ pthread_cond_t *cond = cbuffer->cond;
++ unsigned g = cbuffer->wseq & 1;
+
+-int
+-__pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex)
++ __condvar_dec_grefs (cond, g, cbuffer->private);
++
++ __condvar_cancel_waiting (cond, cbuffer->wseq >> 1, g, cbuffer->private);
++ /* FIXME With the current cancellation implementation, it is possible that
++ a thread is cancelled after it has returned from a syscall. This could
++ result in a cancelled waiter consuming a futex wake-up that is then
++ causing another waiter in the same group to not wake up. To work around
++ this issue until we have fixed cancellation, just add a futex wake-up
++ conservatively. */
++ futex_wake (cond->__data.__g_signals + g, 1, cbuffer->private);
++
++ __condvar_confirm_wakeup (cond, cbuffer->private);
++
++ /* XXX If locking the mutex fails, should we just stop execution? This
++ might be better than silently ignoring the error. */
++ __pthread_mutex_cond_lock (cbuffer->mutex);
++}
++
++/* This condvar implementation guarantees that all calls to signal and
++ broadcast and all of the three virtually atomic parts of each call to wait
++ (i.e., (1) releasing the mutex and blocking, (2) unblocking, and (3) re-
++ acquiring the mutex) happen in some total order that is consistent with the
++ happens-before relations in the calling program. However, this order does
++ not necessarily result in additional happens-before relations being
++ established (which aligns well with spurious wake-ups being allowed).
++
++ All waiters acquire a certain position in a 64b waiter sequence (__wseq).
++ This sequence determines which waiters are allowed to consume signals.
++ A broadcast is equal to sending as many signals as are unblocked waiters.
++ When a signal arrives, it samples the current value of __wseq with a
++ relaxed-MO load (i.e., the position the next waiter would get). (This is
++ sufficient because it is consistent with happens-before; the caller can
++ enforce stronger ordering constraints by calling signal while holding the
++ mutex.) Only waiters with a position less than the __wseq value observed
++ by the signal are eligible to consume this signal.
++
++ This would be straight-forward to implement if waiters would just spin but
++ we need to let them block using futexes. Futexes give no guarantee of
++ waking in FIFO order, so we cannot reliably wake eligible waiters if we
++ just use a single futex. Also, futex words are 32b in size, but we need
++ to distinguish more than 1<<32 states because we need to represent the
++ order of wake-up (and thus which waiters are eligible to consume signals);
++ blocking in a futex is not atomic with a waiter determining its position in
++ the waiter sequence, so we need the futex word to reliably notify waiters
++ that they should not attempt to block anymore because they have been
++ already signaled in the meantime. While an ABA issue on a 32b value will
++ be rare, ignoring it when we are aware of it is not the right thing to do
++ either.
++
++ Therefore, we use a 64b counter to represent the waiter sequence (on
++ architectures which only support 32b atomics, we use a few bits less).
++ To deal with the blocking using futexes, we maintain two groups of waiters:
++ * Group G1 consists of waiters that are all eligible to consume signals;
++ incoming signals will always signal waiters in this group until all
++ waiters in G1 have been signaled.
++ * Group G2 consists of waiters that arrive when a G1 is present and still
++ contains waiters that have not been signaled. When all waiters in G1
++ are signaled and a new signal arrives, the new signal will convert G2
++ into the new G1 and create a new G2 for future waiters.
++
++ We cannot allocate new memory because of process-shared condvars, so we
++ have just two slots of groups that change their role between G1 and G2.
++ Each has a separate futex word, a number of signals available for
++ consumption, a size (number of waiters in the group that have not been
++ signaled), and a reference count.
++
++ The group reference count is used to maintain the number of waiters that
++ are using the group's futex. Before a group can change its role, the
++ reference count must show that no waiters are using the futex anymore; this
++ prevents ABA issues on the futex word.
++
++ To represent which intervals in the waiter sequence the groups cover (and
++ thus also which group slot contains G1 or G2), we use a 64b counter to
++ designate the start position of G1 (inclusive), and a single bit in the
++ waiter sequence counter to represent which group slot currently contains
++ G2. This allows us to switch group roles atomically wrt. waiters obtaining
++ a position in the waiter sequence. The G1 start position allows waiters to
++ figure out whether they are in a group that has already been completely
++ signaled (i.e., if the current G1 starts at a later position that the
++ waiter's position). Waiters cannot determine whether they are currently
++ in G2 or G1 -- but they do not have too because all they are interested in
++ is whether there are available signals, and they always start in G2 (whose
++ group slot they know because of the bit in the waiter sequence. Signalers
++ will simply fill the right group until it is completely signaled and can
++ be closed (they do not switch group roles until they really have to to
++ decrease the likelihood of having to wait for waiters still holding a
++ reference on the now-closed G1).
++
++ Signalers maintain the initial size of G1 to be able to determine where
++ G2 starts (G2 is always open-ended until it becomes G1). They track the
++ remaining size of a group; when waiters cancel waiting (due to PThreads
++ cancellation or timeouts), they will decrease this remaining size as well.
++
++ To implement condvar destruction requirements (i.e., that
++ pthread_cond_destroy can be called as soon as all waiters have been
++ signaled), waiters increment a reference count before starting to wait and
++ decrement it after they stopped waiting but right before they acquire the
++ mutex associated with the condvar.
++
++ pthread_cond_t thus consists of the following (bits that are used for
++ flags and are not part of the primary value of each field but necessary
++ to make some things atomic or because there was no space for them
++ elsewhere in the data structure):
++
++ __wseq: Waiter sequence counter
++ * LSB is index of current G2.
++ * Waiters fetch-add while having acquire the mutex associated with the
++ condvar. Signalers load it and fetch-xor it concurrently.
++ __g1_start: Starting position of G1 (inclusive)
++ * LSB is index of current G2.
++ * Modified by signalers while having acquired the condvar-internal lock
++ and observed concurrently by waiters.
++ __g1_orig_size: Initial size of G1
++ * The two least-significant bits represent the condvar-internal lock.
++ * Only accessed while having acquired the condvar-internal lock.
++ __wrefs: Waiter reference counter.
++ * Bit 2 is true if waiters should run futex_wake when they remove the
++ last reference. pthread_cond_destroy uses this as futex word.
++ * Bit 1 is the clock ID (0 == CLOCK_REALTIME, 1 == CLOCK_MONOTONIC).
++ * Bit 0 is true iff this is a process-shared condvar.
++ * Simple reference count used by both waiters and pthread_cond_destroy.
++ (If the format of __wrefs is changed, update nptl_lock_constants.pysym
++ and the pretty printers.)
++ For each of the two groups, we have:
++ __g_refs: Futex waiter reference count.
++ * LSB is true if waiters should run futex_wake when they remove the
++ last reference.
++ * Reference count used by waiters concurrently with signalers that have
++ acquired the condvar-internal lock.
++ __g_signals: The number of signals that can still be consumed.
++ * Used as a futex word by waiters. Used concurrently by waiters and
++ signalers.
++ * LSB is true iff this group has been completely signaled (i.e., it is
++ closed).
++ __g_size: Waiters remaining in this group (i.e., which have not been
++ signaled yet.
++ * Accessed by signalers and waiters that cancel waiting (both do so only
++ when having acquired the condvar-internal lock.
++ * The size of G2 is always zero because it cannot be determined until
++ the group becomes G1.
++ * Although this is of unsigned type, we rely on using unsigned overflow
++ rules to make this hold effectively negative values too (in
++ particular, when waiters in G2 cancel waiting).
++
++ A PTHREAD_COND_INITIALIZER condvar has all fields set to zero, which yields
++ a condvar that has G2 starting at position 0 and a G1 that is closed.
++
++ Because waiters do not claim ownership of a group right when obtaining a
++ position in __wseq but only reference count the group when using futexes
++ to block, it can happen that a group gets closed before a waiter can
++ increment the reference count. Therefore, waiters have to check whether
++ their group is already closed using __g1_start. They also have to perform
++ this check when spinning when trying to grab a signal from __g_signals.
++ Note that for these checks, using relaxed MO to load __g1_start is
++ sufficient because if a waiter can see a sufficiently large value, it could
++ have also consume a signal in the waiters group.
++
++ Waiters try to grab a signal from __g_signals without holding a reference
++ count, which can lead to stealing a signal from a more recent group after
++ their own group was already closed. They cannot always detect whether they
++ in fact did because they do not know when they stole, but they can
++ conservatively add a signal back to the group they stole from; if they
++ did so unnecessarily, all that happens is a spurious wake-up. To make this
++ even less likely, __g1_start contains the index of the current g2 too,
++ which allows waiters to check if there aliasing on the group slots; if
++ there wasn't, they didn't steal from the current G1, which means that the
++ G1 they stole from must have been already closed and they do not need to
++ fix anything.
++
++ It is essential that the last field in pthread_cond_t is __g_signals[1]:
++ The previous condvar used a pointer-sized field in pthread_cond_t, so a
++ PTHREAD_COND_INITIALIZER from that condvar implementation might only
++ initialize 4 bytes to zero instead of the 8 bytes we need (i.e., 44 bytes
++ in total instead of the 48 we need). __g_signals[1] is not accessed before
++ the first group switch (G2 starts at index 0), which will set its value to
++ zero after a harmless fetch-or whose return value is ignored. This
++ effectively completes initialization.
++
++
++ Limitations:
++ * This condvar isn't designed to allow for more than
++ __PTHREAD_COND_MAX_GROUP_SIZE * (1 << 31) calls to __pthread_cond_wait.
++ * More than __PTHREAD_COND_MAX_GROUP_SIZE concurrent waiters are not
++ supported.
++ * Beyond what is allowed as errors by POSIX or documented, we can also
++ return the following errors:
++ * EPERM if MUTEX is a recursive mutex and the caller doesn't own it.
++ * EOWNERDEAD or ENOTRECOVERABLE when using robust mutexes. Unlike
++ for other errors, this can happen when we re-acquire the mutex; this
++ isn't allowed by POSIX (which requires all errors to virtually happen
++ before we release the mutex or change the condvar state), but there's
++ nothing we can do really.
++ * When using PTHREAD_MUTEX_PP_* mutexes, we can also return all errors
++ returned by __pthread_tpp_change_priority. We will already have
++ released the mutex in such cases, so the caller cannot expect to own
++ MUTEX.
++
++ Other notes:
++ * Instead of the normal mutex unlock / lock functions, we use
++ __pthread_mutex_unlock_usercnt(m, 0) / __pthread_mutex_cond_lock(m)
++ because those will not change the mutex-internal users count, so that it
++ can be detected when a condvar is still associated with a particular
++ mutex because there is a waiter blocked on this condvar using this mutex.
++*/
++static __always_inline int
++__pthread_cond_wait_common (pthread_cond_t *cond, pthread_mutex_t *mutex,
++ const struct timespec *abstime)
+ {
+- struct _pthread_cleanup_buffer buffer;
+- struct _condvar_cleanup_buffer cbuffer;
++ const int maxspin = 0;
+ int err;
+- int pshared = (cond->__data.__mutex == (void *) ~0l)
+- ? LLL_SHARED : LLL_PRIVATE;
+-
+-#if (defined lll_futex_wait_requeue_pi \
+- && defined __ASSUME_REQUEUE_PI)
+- int pi_flag = 0;
+-#endif
++ int result = 0;
+
+ LIBC_PROBE (cond_wait, 2, cond, mutex);
+
+- /* Make sure we are alone. */
+- lll_lock (cond->__data.__lock, pshared);
+-
+- /* Now we can release the mutex. */
++ /* Acquire a position (SEQ) in the waiter sequence (WSEQ). We use an
++ atomic operation because signals and broadcasts may update the group
++ switch without acquiring the mutex. We do not need release MO here
++ because we do not need to establish any happens-before relation with
++ signalers (see __pthread_cond_signal); modification order alone
++ establishes a total order of waiters/signals. We do need acquire MO
++ to synchronize with group reinitialization in
++ __condvar_quiesce_and_switch_g1. */
++ uint64_t wseq = __condvar_fetch_add_wseq_acquire (cond, 2);
++ /* Find our group's index. We always go into what was G2 when we acquired
++ our position. */
++ unsigned int g = wseq & 1;
++ uint64_t seq = wseq >> 1;
++
++ /* Increase the waiter reference count. Relaxed MO is sufficient because
++ we only need to synchronize when decrementing the reference count. */
++ unsigned int flags = atomic_fetch_add_relaxed (&cond->__data.__wrefs, 8);
++ int private = __condvar_get_private (flags);
++
++ /* Now that we are registered as a waiter, we can release the mutex.
++ Waiting on the condvar must be atomic with releasing the mutex, so if
++ the mutex is used to establish a happens-before relation with any
++ signaler, the waiter must be visible to the latter; thus, we release the
++ mutex after registering as waiter.
++ If releasing the mutex fails, we just cancel our registration as a
++ waiter and confirm that we have woken up. */
+ err = __pthread_mutex_unlock_usercnt (mutex, 0);
+- if (__glibc_unlikely (err))
++ if (__glibc_unlikely (err != 0))
+ {
+- lll_unlock (cond->__data.__lock, pshared);
++ __condvar_cancel_waiting (cond, seq, g, private);
++ __condvar_confirm_wakeup (cond, private);
+ return err;
+ }
+
+- /* We have one new user of the condvar. */
+- ++cond->__data.__total_seq;
+- ++cond->__data.__futex;
+- cond->__data.__nwaiters += 1 << COND_NWAITERS_SHIFT;
+-
+- /* Remember the mutex we are using here. If there is already a
+- different address store this is a bad user bug. Do not store
+- anything for pshared condvars. */
+- if (cond->__data.__mutex != (void *) ~0l)
+- cond->__data.__mutex = mutex;
+-
+- /* Prepare structure passed to cancellation handler. */
+- cbuffer.cond = cond;
+- cbuffer.mutex = mutex;
+-
+- /* Before we block we enable cancellation. Therefore we have to
+- install a cancellation handler. */
+- __pthread_cleanup_push (&buffer, __condvar_cleanup, &cbuffer);
+-
+- /* The current values of the wakeup counter. The "woken" counter
+- must exceed this value. */
+- unsigned long long int val;
+- unsigned long long int seq;
+- val = seq = cond->__data.__wakeup_seq;
+- /* Remember the broadcast counter. */
+- cbuffer.bc_seq = cond->__data.__broadcast_seq;
++ /* Now wait until a signal is available in our group or it is closed.
++ Acquire MO so that if we observe a value of zero written after group
++ switching in __condvar_quiesce_and_switch_g1, we synchronize with that
++ store and will see the prior update of __g1_start done while switching
++ groups too. */
++ unsigned int signals = atomic_load_acquire (cond->__data.__g_signals + g);
+
+ do
+ {
+- unsigned int futex_val = cond->__data.__futex;
+- /* Prepare to wait. Release the condvar futex. */
+- lll_unlock (cond->__data.__lock, pshared);
+-
+- /* Enable asynchronous cancellation. Required by the standard. */
+- cbuffer.oldtype = __pthread_enable_asynccancel ();
+-
+-#if (defined lll_futex_wait_requeue_pi \
+- && defined __ASSUME_REQUEUE_PI)
+- /* If pi_flag remained 1 then it means that we had the lock and the mutex
+- but a spurious waker raced ahead of us. Give back the mutex before
+- going into wait again. */
+- if (pi_flag)
++ while (1)
+ {
+- __pthread_mutex_cond_lock_adjust (mutex);
+- __pthread_mutex_unlock_usercnt (mutex, 0);
++ /* Spin-wait first.
++ Note that spinning first without checking whether a timeout
++ passed might lead to what looks like a spurious wake-up even
++ though we should return ETIMEDOUT (e.g., if the caller provides
++ an absolute timeout that is clearly in the past). However,
++ (1) spurious wake-ups are allowed, (2) it seems unlikely that a
++ user will (ab)use pthread_cond_wait as a check for whether a
++ point in time is in the past, and (3) spinning first without
++ having to compare against the current time seems to be the right
++ choice from a performance perspective for most use cases. */
++ unsigned int spin = maxspin;
++ while (signals == 0 && spin > 0)
++ {
++ /* Check that we are not spinning on a group that's already
++ closed. */
++ if (seq < (__condvar_load_g1_start_relaxed (cond) >> 1))
++ goto done;
++
++ /* TODO Back off. */
++
++ /* Reload signals. See above for MO. */
++ signals = atomic_load_acquire (cond->__data.__g_signals + g);
++ spin--;
++ }
++
++ /* If our group will be closed as indicated by the flag on signals,
++ don't bother grabbing a signal. */
++ if (signals & 1)
++ goto done;
++
++ /* If there is an available signal, don't block. */
++ if (signals != 0)
++ break;
++
++ /* No signals available after spinning, so prepare to block.
++ We first acquire a group reference and use acquire MO for that so
++ that we synchronize with the dummy read-modify-write in
++ __condvar_quiesce_and_switch_g1 if we read from that. In turn,
++ in this case this will make us see the closed flag on __g_signals
++ that designates a concurrent attempt to reuse the group's slot.
++ We use acquire MO for the __g_signals check to make the
++ __g1_start check work (see spinning above).
++ Note that the group reference acquisition will not mask the
++ release MO when decrementing the reference count because we use
++ an atomic read-modify-write operation and thus extend the release
++ sequence. */
++ atomic_fetch_add_acquire (cond->__data.__g_refs + g, 2);
++ if (((atomic_load_acquire (cond->__data.__g_signals + g) & 1) != 0)
++ || (seq < (__condvar_load_g1_start_relaxed (cond) >> 1)))
++ {
++ /* Our group is closed. Wake up any signalers that might be
++ waiting. */
++ __condvar_dec_grefs (cond, g, private);
++ goto done;
++ }
++
++ // Now block.
++ struct _pthread_cleanup_buffer buffer;
++ struct _condvar_cleanup_buffer cbuffer;
++ cbuffer.wseq = wseq;
++ cbuffer.cond = cond;
++ cbuffer.mutex = mutex;
++ cbuffer.private = private;
++ __pthread_cleanup_push (&buffer, __condvar_cleanup_waiting, &cbuffer);
++
++ if (abstime == NULL)
++ {
++ /* Block without a timeout. */
++ err = futex_wait_cancelable (
++ cond->__data.__g_signals + g, 0, private);
++ }
++ else
++ {
++ /* Block, but with a timeout.
++ Work around the fact that the kernel rejects negative timeout
++ values despite them being valid. */
++ if (__glibc_unlikely (abstime->tv_sec < 0))
++ err = ETIMEDOUT;
++
++ else if ((flags & __PTHREAD_COND_CLOCK_MONOTONIC_MASK) != 0)
++ {
++ /* CLOCK_MONOTONIC is requested. */
++ struct timespec rt;
++ if (__clock_gettime (CLOCK_MONOTONIC, &rt) != 0)
++ __libc_fatal ("clock_gettime does not support "
++ "CLOCK_MONOTONIC");
++ /* Convert the absolute timeout value to a relative
++ timeout. */
++ rt.tv_sec = abstime->tv_sec - rt.tv_sec;
++ rt.tv_nsec = abstime->tv_nsec - rt.tv_nsec;
++ if (rt.tv_nsec < 0)
++ {
++ rt.tv_nsec += 1000000000;
++ --rt.tv_sec;
++ }
++ /* Did we already time out? */
++ if (__glibc_unlikely (rt.tv_sec < 0))
++ err = ETIMEDOUT;
++ else
++ err = futex_reltimed_wait_cancelable
++ (cond->__data.__g_signals + g, 0, &rt, private);
++ }
++ else
++ {
++ /* Use CLOCK_REALTIME. */
++ err = futex_abstimed_wait_cancelable
++ (cond->__data.__g_signals + g, 0, abstime, private);
++ }
++ }
++
++ __pthread_cleanup_pop (&buffer, 0);
++
++ if (__glibc_unlikely (err == ETIMEDOUT))
++ {
++ __condvar_dec_grefs (cond, g, private);
++ /* If we timed out, we effectively cancel waiting. Note that
++ we have decremented __g_refs before cancellation, so that a
++ deadlock between waiting for quiescence of our group in
++ __condvar_quiesce_and_switch_g1 and us trying to acquire
++ the lock during cancellation is not possible. */
++ __condvar_cancel_waiting (cond, seq, g, private);
++ result = ETIMEDOUT;
++ goto done;
++ }
++ else
++ __condvar_dec_grefs (cond, g, private);
++
++ /* Reload signals. See above for MO. */
++ signals = atomic_load_acquire (cond->__data.__g_signals + g);
+ }
+- pi_flag = USE_REQUEUE_PI (mutex);
+
+- if (pi_flag)
++ }
++ /* Try to grab a signal. Use acquire MO so that we see an up-to-date value
++ of __g1_start below (see spinning above for a similar case). In
++ particular, if we steal from a more recent group, we will also see a
++ more recent __g1_start below. */
++ while (!atomic_compare_exchange_weak_acquire (cond->__data.__g_signals + g,
++ &signals, signals - 2));
++
++ /* We consumed a signal but we could have consumed from a more recent group
++ that aliased with ours due to being in the same group slot. If this
++ might be the case our group must be closed as visible through
++ __g1_start. */
++ uint64_t g1_start = __condvar_load_g1_start_relaxed (cond);
++ if (seq < (g1_start >> 1))
++ {
++ /* We potentially stole a signal from a more recent group but we do not
++ know which group we really consumed from.
++ We do not care about groups older than current G1 because they are
++ closed; we could have stolen from these, but then we just add a
++ spurious wake-up for the current groups.
++ We will never steal a signal from current G2 that was really intended
++ for G2 because G2 never receives signals (until it becomes G1). We
++ could have stolen a signal from G2 that was conservatively added by a
++ previous waiter that also thought it stole a signal -- but given that
++ that signal was added unnecessarily, it's not a problem if we steal
++ it.
++ Thus, the remaining case is that we could have stolen from the current
++ G1, where "current" means the __g1_start value we observed. However,
++ if the current G1 does not have the same slot index as we do, we did
++ not steal from it and do not need to undo that. This is the reason
++ for putting a bit with G2's index into__g1_start as well. */
++ if (((g1_start & 1) ^ 1) == g)
+ {
+- err = lll_futex_wait_requeue_pi (&cond->__data.__futex,
+- futex_val, &mutex->__data.__lock,
+- pshared);
+-
+- pi_flag = (err == 0);
++ /* We have to conservatively undo our potential mistake of stealing
++ a signal. We can stop trying to do that when the current G1
++ changes because other spinning waiters will notice this too and
++ __condvar_quiesce_and_switch_g1 has checked that there are no
++ futex waiters anymore before switching G1.
++ Relaxed MO is fine for the __g1_start load because we need to
++ merely be able to observe this fact and not have to observe
++ something else as well.
++ ??? Would it help to spin for a little while to see whether the
++ current G1 gets closed? This might be worthwhile if the group is
++ small or close to being closed. */
++ unsigned int s = atomic_load_relaxed (cond->__data.__g_signals + g);
++ while (__condvar_load_g1_start_relaxed (cond) == g1_start)
++ {
++ /* Try to add a signal. We don't need to acquire the lock
++ because at worst we can cause a spurious wake-up. If the
++ group is in the process of being closed (LSB is true), this
++ has an effect similar to us adding a signal. */
++ if (((s & 1) != 0)
++ || atomic_compare_exchange_weak_relaxed
++ (cond->__data.__g_signals + g, &s, s + 2))
++ {
++ /* If we added a signal, we also need to add a wake-up on
++ the futex. We also need to do that if we skipped adding
++ a signal because the group is being closed because
++ while __condvar_quiesce_and_switch_g1 could have closed
++ the group, it might stil be waiting for futex waiters to
++ leave (and one of those waiters might be the one we stole
++ the signal from, which cause it to block using the
++ futex). */
++ futex_wake (cond->__data.__g_signals + g, 1, private);
++ break;
++ }
++ /* TODO Back off. */
++ }
+ }
+- else
+-#endif
+- /* Wait until woken by signal or broadcast. */
+- lll_futex_wait (&cond->__data.__futex, futex_val, pshared);
+-
+- /* Disable asynchronous cancellation. */
+- __pthread_disable_asynccancel (cbuffer.oldtype);
+-
+- /* We are going to look at shared data again, so get the lock. */
+- lll_lock (cond->__data.__lock, pshared);
+-
+- /* If a broadcast happened, we are done. */
+- if (cbuffer.bc_seq != cond->__data.__broadcast_seq)
+- goto bc_out;
+-
+- /* Check whether we are eligible for wakeup. */
+- val = cond->__data.__wakeup_seq;
+ }
+- while (val == seq || cond->__data.__woken_seq == val);
+
+- /* Another thread woken up. */
+- ++cond->__data.__woken_seq;
++ done:
+
+- bc_out:
++ /* Confirm that we have been woken. We do that before acquiring the mutex
++ to allow for execution of pthread_cond_destroy while having acquired the
++ mutex. */
++ __condvar_confirm_wakeup (cond, private);
+
+- cond->__data.__nwaiters -= 1 << COND_NWAITERS_SHIFT;
+-
+- /* If pthread_cond_destroy was called on this varaible already,
+- notify the pthread_cond_destroy caller all waiters have left
+- and it can be successfully destroyed. */
+- if (cond->__data.__total_seq == -1ULL
+- && cond->__data.__nwaiters < (1 << COND_NWAITERS_SHIFT))
+- lll_futex_wake (&cond->__data.__nwaiters, 1, pshared);
++ /* Woken up; now re-acquire the mutex. If this doesn't fail, return RESULT,
++ which is set to ETIMEDOUT if a timeout occured, or zero otherwise. */
++ err = __pthread_mutex_cond_lock (mutex);
++ /* XXX Abort on errors that are disallowed by POSIX? */
++ return (err != 0) ? err : result;
++}
+
+- /* We are done with the condvar. */
+- lll_unlock (cond->__data.__lock, pshared);
+
+- /* The cancellation handling is back to normal, remove the handler. */
+- __pthread_cleanup_pop (&buffer, 0);
++/* See __pthread_cond_wait_common. */
++int
++__pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex)
++{
++ return __pthread_cond_wait_common (cond, mutex, NULL);
++}
+
+- /* Get the mutex before returning. Not needed for PI. */
+-#if (defined lll_futex_wait_requeue_pi \
+- && defined __ASSUME_REQUEUE_PI)
+- if (pi_flag)
+- {
+- __pthread_mutex_cond_lock_adjust (mutex);
+- return 0;
+- }
+- else
+-#endif
+- return __pthread_mutex_cond_lock (mutex);
++/* See __pthread_cond_wait_common. */
++int
++__pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex,
++ const struct timespec *abstime)
++{
++ /* Check parameter validity. This should also tell the compiler that
++ it can assume that abstime is not NULL. */
++ if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
++ return EINVAL;
++ return __pthread_cond_wait_common (cond, mutex, abstime);
+ }
+
+ versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait,
+ GLIBC_2_3_2);
++versioned_symbol (libpthread, __pthread_cond_timedwait, pthread_cond_timedwait,
++ GLIBC_2_3_2);
+diff --git a/nptl/pthread_condattr_getclock.c b/nptl/pthread_condattr_getclock.c
+index d156302..cecb4aa 100644
+--- a/nptl/pthread_condattr_getclock.c
++++ b/nptl/pthread_condattr_getclock.c
+@@ -23,6 +23,6 @@ int
+ pthread_condattr_getclock (const pthread_condattr_t *attr, clockid_t *clock_id)
+ {
+ *clock_id = (((((const struct pthread_condattr *) attr)->value) >> 1)
+- & ((1 << COND_NWAITERS_SHIFT) - 1));
++ & ((1 << COND_CLOCK_BITS) - 1));
+ return 0;
+ }
+diff --git a/nptl/pthread_condattr_getpshared.c b/nptl/pthread_condattr_getpshared.c
+index 5a10f3e..8147966 100644
+--- a/nptl/pthread_condattr_getpshared.c
++++ b/nptl/pthread_condattr_getpshared.c
+@@ -22,7 +22,8 @@
+ int
+ pthread_condattr_getpshared (const pthread_condattr_t *attr, int *pshared)
+ {
+- *pshared = ((const struct pthread_condattr *) attr)->value & 1;
++ *pshared = (((const struct pthread_condattr *) attr)->value & 1
++ ? PTHREAD_PROCESS_SHARED : PTHREAD_PROCESS_PRIVATE);
+
+ return 0;
+ }
+diff --git a/nptl/pthread_condattr_init.c b/nptl/pthread_condattr_init.c
+index 0ce42e5..6e5168d 100644
+--- a/nptl/pthread_condattr_init.c
++++ b/nptl/pthread_condattr_init.c
+@@ -23,7 +23,9 @@
+ int
+ __pthread_condattr_init (pthread_condattr_t *attr)
+ {
+- memset (attr, '\0', sizeof (*attr));
++ struct pthread_condattr *iattr = (struct pthread_condattr *) attr;
++ /* Default is not pshared and CLOCK_REALTIME. */
++ iattr-> value = CLOCK_REALTIME << 1;
+
+ return 0;
+ }
+diff --git a/nptl/pthread_condattr_setclock.c b/nptl/pthread_condattr_setclock.c
+index 25e2a17..3cfad84 100644
+--- a/nptl/pthread_condattr_setclock.c
++++ b/nptl/pthread_condattr_setclock.c
+@@ -18,7 +18,7 @@
+
+ #include <assert.h>
+ #include <errno.h>
+-#include <stdbool.h>
++#include <futex-internal.h>
+ #include <time.h>
+ #include <sysdep.h>
+ #include "pthreadP.h"
+@@ -33,12 +33,17 @@ pthread_condattr_setclock (pthread_condattr_t *attr, clockid_t clock_id)
+ in the pthread_cond_t structure needs to be adjusted. */
+ return EINVAL;
+
++ /* If we do not support waiting using CLOCK_MONOTONIC, return an error. */
++ if (clock_id == CLOCK_MONOTONIC
++ && !futex_supports_exact_relative_timeouts())
++ return ENOTSUP;
++
+ /* Make sure the value fits in the bits we reserved. */
+- assert (clock_id < (1 << COND_NWAITERS_SHIFT));
++ assert (clock_id < (1 << COND_CLOCK_BITS));
+
+ int *valuep = &((struct pthread_condattr *) attr)->value;
+
+- *valuep = ((*valuep & ~(((1 << COND_NWAITERS_SHIFT) - 1) << 1))
++ *valuep = ((*valuep & ~(((1 << COND_CLOCK_BITS) - 1) << 1))
+ | (clock_id << 1));
+
+ return 0;
+diff --git a/nptl/test-cond-printers.py b/nptl/test-cond-printers.py
+index af0e12e..9e807c9 100644
+--- a/nptl/test-cond-printers.py
++++ b/nptl/test-cond-printers.py
+@@ -35,7 +35,7 @@ try:
+
+ break_at(test_source, 'Test status (destroyed)')
+ continue_cmd() # Go to test_status_destroyed
+- test_printer(var, to_string, {'Status': 'Destroyed'})
++ test_printer(var, to_string, {'Threads known to still execute a wait function': '0'})
+
+ continue_cmd() # Exit
+
+diff --git a/nptl/tst-cond1.c b/nptl/tst-cond1.c
+index 75ab9c8..509bbd0 100644
+--- a/nptl/tst-cond1.c
++++ b/nptl/tst-cond1.c
+@@ -73,6 +73,9 @@ do_test (void)
+
+ puts ("parent: wait for condition");
+
++ /* This test will fail on spurious wake-ups, which are allowed; however,
++ the current implementation shouldn't produce spurious wake-ups in the
++ scenario we are testing here. */
+ err = pthread_cond_wait (&cond, &mut);
+ if (err != 0)
+ error (EXIT_FAILURE, err, "parent: cannot wait fir signal");
+diff --git a/nptl/tst-cond20.c b/nptl/tst-cond20.c
+index 918c4ad..665a66a 100644
+--- a/nptl/tst-cond20.c
++++ b/nptl/tst-cond20.c
+@@ -96,7 +96,10 @@ do_test (void)
+
+ for (i = 0; i < ROUNDS; ++i)
+ {
+- pthread_cond_wait (&cond2, &mut);
++ /* Make sure we discard spurious wake-ups. */
++ do
++ pthread_cond_wait (&cond2, &mut);
++ while (count != N);
+
+ if (i & 1)
+ pthread_mutex_unlock (&mut);
+diff --git a/nptl/tst-cond22.c b/nptl/tst-cond22.c
+index bd978e5..64f19ea 100644
+--- a/nptl/tst-cond22.c
++++ b/nptl/tst-cond22.c
+@@ -106,10 +106,11 @@ do_test (void)
+ status = 1;
+ }
+
+- printf ("cond = { %d, %x, %lld, %lld, %lld, %p, %u, %u }\n",
+- c.__data.__lock, c.__data.__futex, c.__data.__total_seq,
+- c.__data.__wakeup_seq, c.__data.__woken_seq, c.__data.__mutex,
+- c.__data.__nwaiters, c.__data.__broadcast_seq);
++ printf ("cond = { %llu, %llu, %u/%u/%u, %u/%u/%u, %u, %u }\n",
++ c.__data.__wseq, c.__data.__g1_start,
++ c.__data.__g_signals[0], c.__data.__g_refs[0], c.__data.__g_size[0],
++ c.__data.__g_signals[1], c.__data.__g_refs[1], c.__data.__g_size[1],
++ c.__data.__g1_orig_size, c.__data.__wrefs);
+
+ if (pthread_create (&th, NULL, tf, (void *) 1l) != 0)
+ {
+@@ -148,10 +149,11 @@ do_test (void)
+ status = 1;
+ }
+
+- printf ("cond = { %d, %x, %lld, %lld, %lld, %p, %u, %u }\n",
+- c.__data.__lock, c.__data.__futex, c.__data.__total_seq,
+- c.__data.__wakeup_seq, c.__data.__woken_seq, c.__data.__mutex,
+- c.__data.__nwaiters, c.__data.__broadcast_seq);
++ printf ("cond = { %llu, %llu, %u/%u/%u, %u/%u/%u, %u, %u }\n",
++ c.__data.__wseq, c.__data.__g1_start,
++ c.__data.__g_signals[0], c.__data.__g_refs[0], c.__data.__g_size[0],
++ c.__data.__g_signals[1], c.__data.__g_refs[1], c.__data.__g_size[1],
++ c.__data.__g1_orig_size, c.__data.__wrefs);
+
+ return status;
+ }
+diff --git a/sysdeps/aarch64/nptl/bits/pthreadtypes.h b/sysdeps/aarch64/nptl/bits/pthreadtypes.h
+index 13984a7..c6fa632 100644
+--- a/sysdeps/aarch64/nptl/bits/pthreadtypes.h
++++ b/sysdeps/aarch64/nptl/bits/pthreadtypes.h
+@@ -90,17 +90,30 @@ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+- long int __align;
++ __extension__ long long int __align;
+ } pthread_cond_t;
+
+ typedef union
+diff --git a/sysdeps/arm/nptl/bits/pthreadtypes.h b/sysdeps/arm/nptl/bits/pthreadtypes.h
+index afb5392..53518c6 100644
+--- a/sysdeps/arm/nptl/bits/pthreadtypes.h
++++ b/sysdeps/arm/nptl/bits/pthreadtypes.h
+@@ -93,14 +93,27 @@ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+diff --git a/sysdeps/ia64/nptl/bits/pthreadtypes.h b/sysdeps/ia64/nptl/bits/pthreadtypes.h
+index f2e6dac..e72dbfd 100644
+--- a/sysdeps/ia64/nptl/bits/pthreadtypes.h
++++ b/sysdeps/ia64/nptl/bits/pthreadtypes.h
+@@ -90,17 +90,30 @@ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+- long int __align;
++ __extension__ long long int __align;
+ } pthread_cond_t;
+
+ typedef union
+diff --git a/sysdeps/m68k/nptl/bits/pthreadtypes.h b/sysdeps/m68k/nptl/bits/pthreadtypes.h
+index d8faa7a..c5e9021 100644
+--- a/sysdeps/m68k/nptl/bits/pthreadtypes.h
++++ b/sysdeps/m68k/nptl/bits/pthreadtypes.h
+@@ -88,19 +88,33 @@ typedef union
+
+
+ /* Data structure for conditional variable handling. The structure of
+- the attribute type is deliberately not exposed. */
++ the attribute type is not exposed on purpose. */
+ typedef union
+ {
+ struct
+ {
+- int __lock __attribute__ ((__aligned__ (4)));
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ /* Enforce proper alignment of fields used as futex words. */
++ unsigned int __g_refs[2] __attribute__ ((__aligned__ (4)));
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+diff --git a/sysdeps/microblaze/nptl/bits/pthreadtypes.h b/sysdeps/microblaze/nptl/bits/pthreadtypes.h
+index 9e9e307..b6623c2 100644
+--- a/sysdeps/microblaze/nptl/bits/pthreadtypes.h
++++ b/sysdeps/microblaze/nptl/bits/pthreadtypes.h
+@@ -91,14 +91,27 @@ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+diff --git a/sysdeps/mips/nptl/bits/pthreadtypes.h b/sysdeps/mips/nptl/bits/pthreadtypes.h
+index 68ed94b..7ddc7bf 100644
+--- a/sysdeps/mips/nptl/bits/pthreadtypes.h
++++ b/sysdeps/mips/nptl/bits/pthreadtypes.h
+@@ -117,19 +117,32 @@ typedef union
+
+
+ /* Data structure for conditional variable handling. The structure of
+- the attribute type is deliberately not exposed. */
++ the attribute type is not exposed on purpose. */
+ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+diff --git a/sysdeps/nios2/nptl/bits/pthreadtypes.h b/sysdeps/nios2/nptl/bits/pthreadtypes.h
+index 76076d0..3995e26 100644
+--- a/sysdeps/nios2/nptl/bits/pthreadtypes.h
++++ b/sysdeps/nios2/nptl/bits/pthreadtypes.h
+@@ -88,19 +88,32 @@ typedef union
+
+
+ /* Data structure for conditional variable handling. The structure of
+- the attribute type is deliberately not exposed. */
++ the attribute type is not exposed on purpose. */
+ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+diff --git a/sysdeps/nptl/internaltypes.h b/sysdeps/nptl/internaltypes.h
+index 203c548..31e5a43 100644
+--- a/sysdeps/nptl/internaltypes.h
++++ b/sysdeps/nptl/internaltypes.h
+@@ -68,20 +68,13 @@ struct pthread_condattr
+ {
+ /* Combination of values:
+
+- Bit 0 : flag whether conditional variable will be sharable between
+- processes.
+-
+- Bit 1-7: clock ID. */
++ Bit 0 : flag whether conditional variable will be
++ sharable between processes.
++ Bit 1-COND_CLOCK_BITS: Clock ID. COND_CLOCK_BITS is the number of bits
++ needed to represent the ID of the clock. */
+ int value;
+ };
+-
+-
+-/* The __NWAITERS field is used as a counter and to house the number
+- of bits for other purposes. COND_CLOCK_BITS is the number
+- of bits needed to represent the ID of the clock. COND_NWAITERS_SHIFT
+- is the number of bits reserved for other purposes like the clock. */
+-#define COND_CLOCK_BITS 1
+-#define COND_NWAITERS_SHIFT 1
++#define COND_CLOCK_BITS 1
+
+
+ /* Read-write lock variable attribute data structure. */
+diff --git a/sysdeps/nptl/pthread.h b/sysdeps/nptl/pthread.h
+index fd0894e..c122446 100644
+--- a/sysdeps/nptl/pthread.h
++++ b/sysdeps/nptl/pthread.h
+@@ -183,7 +183,7 @@ enum
+
+
+ /* Conditional variable handling. */
+-#define PTHREAD_COND_INITIALIZER { { 0, 0, 0, 0, 0, (void *) 0, 0, 0 } }
++#define PTHREAD_COND_INITIALIZER { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } }
+
+
+ /* Cleanup buffers */
+diff --git a/sysdeps/s390/nptl/bits/pthreadtypes.h b/sysdeps/s390/nptl/bits/pthreadtypes.h
+index 40d10fe..4e455ab 100644
+--- a/sysdeps/s390/nptl/bits/pthreadtypes.h
++++ b/sysdeps/s390/nptl/bits/pthreadtypes.h
+@@ -142,14 +142,27 @@ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+diff --git a/sysdeps/sh/nptl/bits/pthreadtypes.h b/sysdeps/sh/nptl/bits/pthreadtypes.h
+index 13fbd73..065dd11 100644
+--- a/sysdeps/sh/nptl/bits/pthreadtypes.h
++++ b/sysdeps/sh/nptl/bits/pthreadtypes.h
+@@ -93,14 +93,27 @@ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+diff --git a/sysdeps/tile/nptl/bits/pthreadtypes.h b/sysdeps/tile/nptl/bits/pthreadtypes.h
+index 7d68650..c12737f 100644
+--- a/sysdeps/tile/nptl/bits/pthreadtypes.h
++++ b/sysdeps/tile/nptl/bits/pthreadtypes.h
+@@ -122,14 +122,27 @@ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+diff --git a/sysdeps/unix/sysv/linux/alpha/bits/pthreadtypes.h b/sysdeps/unix/sysv/linux/alpha/bits/pthreadtypes.h
+index 1a1779b..d88b045 100644
+--- a/sysdeps/unix/sysv/linux/alpha/bits/pthreadtypes.h
++++ b/sysdeps/unix/sysv/linux/alpha/bits/pthreadtypes.h
+@@ -84,19 +84,32 @@ typedef union
+
+
+ /* Data structure for conditional variable handling. The structure of
+- the attribute type is deliberately not exposed. */
++ the attribute type is not exposed on purpose. */
+ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+diff --git a/sysdeps/unix/sysv/linux/hppa/internaltypes.h b/sysdeps/unix/sysv/linux/hppa/internaltypes.h
+index 651ce2e..d649657 100644
+--- a/sysdeps/unix/sysv/linux/hppa/internaltypes.h
++++ b/sysdeps/unix/sysv/linux/hppa/internaltypes.h
+@@ -46,32 +46,38 @@ fails because __initializer is zero, and the structure will be used as
+ is correctly. */
+
+ #define cond_compat_clear(var) \
+-({ \
+- int tmp = 0; \
+- var->__data.__lock = 0; \
+- var->__data.__futex = 0; \
+- var->__data.__mutex = NULL; \
+- /* Clear __initializer last, to indicate initialization is done. */ \
+- __asm__ __volatile__ ("stw,ma %1,0(%0)" \
+- : : "r" (&var->__data.__initializer), "r" (tmp) : "memory"); \
++({ \
++ int tmp = 0; \
++ var->__data.__wseq = 0; \
++ var->__data.__signals_sent = 0; \
++ var->__data.__confirmed = 0; \
++ var->__data.__generation = 0; \
++ var->__data.__mutex = NULL; \
++ var->__data.__quiescence_waiters = 0; \
++ var->__data.__clockid = 0; \
++ /* Clear __initializer last, to indicate initialization is done. */ \
++ /* This synchronizes-with the acquire load below. */ \
++ atomic_store_release (&var->__data.__initializer, 0); \
+ })
+
+ #define cond_compat_check_and_clear(var) \
+ ({ \
+- int ret; \
+- volatile int *value = &var->__data.__initializer; \
+- if ((ret = atomic_compare_and_exchange_val_acq(value, 2, 1))) \
++ int v; \
++ int *value = &var->__data.__initializer; \
++ /* This synchronizes-with the release store above. */ \
++ while ((v = atomic_load_acquire (value)) != 0) \
+ { \
+- if (ret == 1) \
++ if (v == 1 \
++ /* Relaxed MO is fine; it only matters who's first. */ \
++ && atomic_compare_exchange_acquire_weak_relaxed (value, 1, 2)) \
+ { \
+- /* Initialize structure. */ \
++ /* We're first; initialize structure. */ \
+ cond_compat_clear (var); \
++ break; \
+ } \
+ else \
+- { \
+- /* Yield until structure is initialized. */ \
+- while (*value == 2) sched_yield (); \
+- } \
++ /* Yield before we re-check initialization status. */ \
++ sched_yield (); \
+ } \
+ })
+
+diff --git a/sysdeps/unix/sysv/linux/hppa/pthread_cond_timedwait.c b/sysdeps/unix/sysv/linux/hppa/pthread_cond_timedwait.c
+deleted file mode 100644
+index ec6fd23..0000000
+--- a/sysdeps/unix/sysv/linux/hppa/pthread_cond_timedwait.c
++++ /dev/null
+@@ -1,41 +0,0 @@
+-/* Copyright (C) 2009-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Carlos O'Donell <carlos at codesourcery.com>, 2009.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library. If not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#ifndef INCLUDED_SELF
+-# define INCLUDED_SELF
+-# include <pthread_cond_timedwait.c>
+-#else
+-# include <pthread.h>
+-# include <pthreadP.h>
+-# include <internaltypes.h>
+-# include <shlib-compat.h>
+-int
+-__pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex,
+- const struct timespec *abstime)
+-{
+- cond_compat_check_and_clear (cond);
+- return __pthread_cond_timedwait_internal (cond, mutex, abstime);
+-}
+-versioned_symbol (libpthread, __pthread_cond_timedwait, pthread_cond_timedwait,
+- GLIBC_2_3_2);
+-# undef versioned_symbol
+-# define versioned_symbol(lib, local, symbol, version)
+-# undef __pthread_cond_timedwait
+-# define __pthread_cond_timedwait __pthread_cond_timedwait_internal
+-# include_next <pthread_cond_timedwait.c>
+-#endif
+diff --git a/sysdeps/unix/sysv/linux/hppa/pthread_cond_wait.c b/sysdeps/unix/sysv/linux/hppa/pthread_cond_wait.c
+index 8f02831..0611f7d 100644
+--- a/sysdeps/unix/sysv/linux/hppa/pthread_cond_wait.c
++++ b/sysdeps/unix/sysv/linux/hppa/pthread_cond_wait.c
+@@ -32,9 +32,22 @@ __pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex)
+ }
+ versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait,
+ GLIBC_2_3_2);
++int
++__pthread_cond_timedwait (cond, mutex, abstime)
++ pthread_cond_t *cond;
++ pthread_mutex_t *mutex;
++ const struct timespec *abstime;
++{
++ cond_compat_check_and_clear (cond);
++ return __pthread_cond_timedwait_internal (cond, mutex, abstime);
++}
++versioned_symbol (libpthread, __pthread_cond_timedwait, pthread_cond_timedwait,
++ GLIBC_2_3_2);
+ # undef versioned_symbol
+ # define versioned_symbol(lib, local, symbol, version)
+ # undef __pthread_cond_wait
+ # define __pthread_cond_wait __pthread_cond_wait_internal
++# undef __pthread_cond_timedwait
++# define __pthread_cond_timedwait __pthread_cond_timedwait_internal
+ # include_next <pthread_cond_wait.c>
+ #endif
+diff --git a/sysdeps/unix/sysv/linux/i386/i686/pthread_cond_timedwait.S b/sysdeps/unix/sysv/linux/i386/i686/pthread_cond_timedwait.S
+deleted file mode 100644
+index f697e5b..0000000
+--- a/sysdeps/unix/sysv/linux/i386/i686/pthread_cond_timedwait.S
++++ /dev/null
+@@ -1,20 +0,0 @@
+-/* Copyright (C) 2003-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Ulrich Drepper <drepper at redhat.com>, 2003.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library; if not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#define HAVE_CMOV 1
+-#include "../pthread_cond_timedwait.S"
+diff --git a/sysdeps/unix/sysv/linux/i386/pthread_cond_broadcast.S b/sysdeps/unix/sysv/linux/i386/pthread_cond_broadcast.S
+deleted file mode 100644
+index 5996688..0000000
+--- a/sysdeps/unix/sysv/linux/i386/pthread_cond_broadcast.S
++++ /dev/null
+@@ -1,241 +0,0 @@
+-/* Copyright (C) 2002-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Ulrich Drepper <drepper at redhat.com>, 2002.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library; if not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#include <sysdep.h>
+-#include <shlib-compat.h>
+-#include <lowlevellock.h>
+-#include <lowlevelcond.h>
+-#include <kernel-features.h>
+-#include <pthread-pi-defines.h>
+-#include <pthread-errnos.h>
+-#include <stap-probe.h>
+-
+- .text
+-
+- /* int pthread_cond_broadcast (pthread_cond_t *cond) */
+- .globl __pthread_cond_broadcast
+- .type __pthread_cond_broadcast, @function
+- .align 16
+-__pthread_cond_broadcast:
+- cfi_startproc
+- pushl %ebx
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%ebx, 0)
+- pushl %esi
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%esi, 0)
+- pushl %edi
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%edi, 0)
+- pushl %ebp
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%ebp, 0)
+- cfi_remember_state
+-
+- movl 20(%esp), %ebx
+-
+- LIBC_PROBE (cond_broadcast, 1, %edx)
+-
+- /* Get internal lock. */
+- movl $1, %edx
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %edx, (%ebx)
+-#else
+- cmpxchgl %edx, cond_lock(%ebx)
+-#endif
+- jnz 1f
+-
+-2: addl $cond_futex, %ebx
+- movl total_seq+4-cond_futex(%ebx), %eax
+- movl total_seq-cond_futex(%ebx), %ebp
+- cmpl wakeup_seq+4-cond_futex(%ebx), %eax
+- ja 3f
+- jb 4f
+- cmpl wakeup_seq-cond_futex(%ebx), %ebp
+- jna 4f
+-
+- /* Cause all currently waiting threads to recognize they are
+- woken up. */
+-3: movl %ebp, wakeup_seq-cond_futex(%ebx)
+- movl %eax, wakeup_seq-cond_futex+4(%ebx)
+- movl %ebp, woken_seq-cond_futex(%ebx)
+- movl %eax, woken_seq-cond_futex+4(%ebx)
+- addl %ebp, %ebp
+- addl $1, broadcast_seq-cond_futex(%ebx)
+- movl %ebp, (%ebx)
+-
+- /* Get the address of the mutex used. */
+- movl dep_mutex-cond_futex(%ebx), %edi
+-
+- /* Unlock. */
+- LOCK
+- subl $1, cond_lock-cond_futex(%ebx)
+- jne 7f
+-
+- /* Don't use requeue for pshared condvars. */
+-8: cmpl $-1, %edi
+- je 9f
+-
+- /* Do not use requeue for pshared condvars. */
+- testl $PS_BIT, MUTEX_KIND(%edi)
+- jne 9f
+-
+- /* Requeue to a non-robust PI mutex if the PI bit is set and
+- the robust bit is not set. */
+- movl MUTEX_KIND(%edi), %eax
+- andl $(ROBUST_BIT|PI_BIT), %eax
+- cmpl $PI_BIT, %eax
+- je 81f
+-
+- /* Wake up all threads. */
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $(FUTEX_CMP_REQUEUE|FUTEX_PRIVATE_FLAG), %ecx
+-#else
+- movl %gs:PRIVATE_FUTEX, %ecx
+- orl $FUTEX_CMP_REQUEUE, %ecx
+-#endif
+- movl $SYS_futex, %eax
+- movl $0x7fffffff, %esi
+- movl $1, %edx
+- /* Get the address of the futex involved. */
+-# if MUTEX_FUTEX != 0
+- addl $MUTEX_FUTEX, %edi
+-# endif
+-/* FIXME: Until Ingo fixes 4G/4G vDSO, 6 arg syscalls are broken for sysenter.
+- ENTER_KERNEL */
+- int $0x80
+-
+- /* For any kind of error, which mainly is EAGAIN, we try again
+- with WAKE. The general test also covers running on old
+- kernels. */
+- cmpl $0xfffff001, %eax
+- jae 9f
+-
+-6: xorl %eax, %eax
+- popl %ebp
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%ebp)
+- popl %edi
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%edi)
+- popl %esi
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%esi)
+- popl %ebx
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%ebx)
+- ret
+-
+- cfi_restore_state
+-
+-81: movl $(FUTEX_CMP_REQUEUE_PI|FUTEX_PRIVATE_FLAG), %ecx
+- movl $SYS_futex, %eax
+- movl $0x7fffffff, %esi
+- movl $1, %edx
+- /* Get the address of the futex involved. */
+-# if MUTEX_FUTEX != 0
+- addl $MUTEX_FUTEX, %edi
+-# endif
+- int $0x80
+-
+- /* For any kind of error, which mainly is EAGAIN, we try again
+- with WAKE. The general test also covers running on old
+- kernels. */
+- cmpl $0xfffff001, %eax
+- jb 6b
+- jmp 9f
+-
+- /* Initial locking failed. */
+-1:
+-#if cond_lock == 0
+- movl %ebx, %edx
+-#else
+- leal cond_lock(%ebx), %edx
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_lock_wait
+- jmp 2b
+-
+- .align 16
+- /* Unlock. */
+-4: LOCK
+- subl $1, cond_lock-cond_futex(%ebx)
+- je 6b
+-
+- /* Unlock in loop requires wakeup. */
+-5: leal cond_lock-cond_futex(%ebx), %eax
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_futex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+- jmp 6b
+-
+- /* Unlock in loop requires wakeup. */
+-7: leal cond_lock-cond_futex(%ebx), %eax
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_futex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+- jmp 8b
+-
+-9: /* The futex requeue functionality is not available. */
+- movl $0x7fffffff, %edx
+-#if FUTEX_PRIVATE_FLAG > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_futex(%ebx)
+- sete %cl
+- subl $1, %ecx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+- addl $FUTEX_WAKE, %ecx
+- movl $SYS_futex, %eax
+- ENTER_KERNEL
+- jmp 6b
+- cfi_endproc
+- .size __pthread_cond_broadcast, .-__pthread_cond_broadcast
+-versioned_symbol (libpthread, __pthread_cond_broadcast, pthread_cond_broadcast,
+- GLIBC_2_3_2)
+diff --git a/sysdeps/unix/sysv/linux/i386/pthread_cond_signal.S b/sysdeps/unix/sysv/linux/i386/pthread_cond_signal.S
+deleted file mode 100644
+index 0038775..0000000
+--- a/sysdeps/unix/sysv/linux/i386/pthread_cond_signal.S
++++ /dev/null
+@@ -1,216 +0,0 @@
+-/* Copyright (C) 2002-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Ulrich Drepper <drepper at redhat.com>, 2002.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library; if not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#include <sysdep.h>
+-#include <shlib-compat.h>
+-#include <lowlevellock.h>
+-#include <lowlevelcond.h>
+-#include <kernel-features.h>
+-#include <pthread-pi-defines.h>
+-#include <pthread-errnos.h>
+-#include <stap-probe.h>
+-
+- .text
+-
+- /* int pthread_cond_signal (pthread_cond_t *cond) */
+- .globl __pthread_cond_signal
+- .type __pthread_cond_signal, @function
+- .align 16
+-__pthread_cond_signal:
+-
+- cfi_startproc
+- pushl %ebx
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%ebx, 0)
+- pushl %edi
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%edi, 0)
+- cfi_remember_state
+-
+- movl 12(%esp), %edi
+-
+- LIBC_PROBE (cond_signal, 1, %edi)
+-
+- /* Get internal lock. */
+- movl $1, %edx
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %edx, (%edi)
+-#else
+- cmpxchgl %edx, cond_lock(%edi)
+-#endif
+- jnz 1f
+-
+-2: leal cond_futex(%edi), %ebx
+- movl total_seq+4(%edi), %eax
+- movl total_seq(%edi), %ecx
+- cmpl wakeup_seq+4(%edi), %eax
+-#if cond_lock != 0
+- /* Must use leal to preserve the flags. */
+- leal cond_lock(%edi), %edi
+-#endif
+- ja 3f
+- jb 4f
+- cmpl wakeup_seq-cond_futex(%ebx), %ecx
+- jbe 4f
+-
+- /* Bump the wakeup number. */
+-3: addl $1, wakeup_seq-cond_futex(%ebx)
+- adcl $0, wakeup_seq-cond_futex+4(%ebx)
+- addl $1, (%ebx)
+-
+- /* Wake up one thread. */
+- pushl %esi
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%esi, 0)
+- pushl %ebp
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%ebp, 0)
+-
+-#if FUTEX_PRIVATE_FLAG > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_futex(%ebx)
+- sete %cl
+- je 8f
+-
+- movl dep_mutex-cond_futex(%ebx), %edx
+- /* Requeue to a non-robust PI mutex if the PI bit is set and
+- the robust bit is not set. */
+- movl MUTEX_KIND(%edx), %eax
+- andl $(ROBUST_BIT|PI_BIT), %eax
+- cmpl $PI_BIT, %eax
+- je 9f
+-
+-8: subl $1, %ecx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+- addl $FUTEX_WAKE_OP, %ecx
+- movl $SYS_futex, %eax
+- movl $1, %edx
+- movl $1, %esi
+- movl $FUTEX_OP_CLEAR_WAKE_IF_GT_ONE, %ebp
+- /* FIXME: Until Ingo fixes 4G/4G vDSO, 6 arg syscalls are broken for
+- sysenter.
+- ENTER_KERNEL */
+- int $0x80
+- popl %ebp
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%ebp)
+- popl %esi
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%esi)
+-
+- /* For any kind of error, we try again with WAKE.
+- The general test also covers running on old kernels. */
+- cmpl $-4095, %eax
+- jae 7f
+-
+-6: xorl %eax, %eax
+- popl %edi
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%edi)
+- popl %ebx
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%ebx)
+- ret
+-
+- cfi_restore_state
+-
+-9: movl $(FUTEX_CMP_REQUEUE_PI|FUTEX_PRIVATE_FLAG), %ecx
+- movl $SYS_futex, %eax
+- movl $1, %edx
+- xorl %esi, %esi
+- movl dep_mutex-cond_futex(%ebx), %edi
+- movl (%ebx), %ebp
+- /* FIXME: Until Ingo fixes 4G/4G vDSO, 6 arg syscalls are broken for
+- sysenter.
+- ENTER_KERNEL */
+- int $0x80
+- popl %ebp
+- popl %esi
+-
+- leal -cond_futex(%ebx), %edi
+-
+- /* For any kind of error, we try again with WAKE.
+- The general test also covers running on old kernels. */
+- cmpl $-4095, %eax
+- jb 4f
+-
+-7:
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+- orl $FUTEX_WAKE, %ecx
+-
+- movl $SYS_futex, %eax
+- /* %edx should be 1 already from $FUTEX_WAKE_OP syscall.
+- movl $1, %edx */
+- ENTER_KERNEL
+-
+- /* Unlock. Note that at this point %edi always points to
+- cond_lock. */
+-4: LOCK
+- subl $1, (%edi)
+- je 6b
+-
+- /* Unlock in loop requires wakeup. */
+-5: movl %edi, %eax
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_futex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+- jmp 6b
+-
+- /* Initial locking failed. */
+-1:
+-#if cond_lock == 0
+- movl %edi, %edx
+-#else
+- leal cond_lock(%edi), %edx
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%edi)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_lock_wait
+- jmp 2b
+-
+- cfi_endproc
+- .size __pthread_cond_signal, .-__pthread_cond_signal
+-versioned_symbol (libpthread, __pthread_cond_signal, pthread_cond_signal,
+- GLIBC_2_3_2)
+diff --git a/sysdeps/unix/sysv/linux/i386/pthread_cond_timedwait.S b/sysdeps/unix/sysv/linux/i386/pthread_cond_timedwait.S
+deleted file mode 100644
+index 6256376..0000000
+--- a/sysdeps/unix/sysv/linux/i386/pthread_cond_timedwait.S
++++ /dev/null
+@@ -1,974 +0,0 @@
+-/* Copyright (C) 2002-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Ulrich Drepper <drepper at redhat.com>, 2002.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library; if not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#include <sysdep.h>
+-#include <shlib-compat.h>
+-#include <lowlevellock.h>
+-#include <lowlevelcond.h>
+-#include <pthread-errnos.h>
+-#include <pthread-pi-defines.h>
+-#include <kernel-features.h>
+-#include <stap-probe.h>
+-
+- .text
+-
+-/* int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex,
+- const struct timespec *abstime) */
+- .globl __pthread_cond_timedwait
+- .type __pthread_cond_timedwait, @function
+- .align 16
+-__pthread_cond_timedwait:
+-.LSTARTCODE:
+- cfi_startproc
+-#ifdef SHARED
+- cfi_personality(DW_EH_PE_pcrel | DW_EH_PE_sdata4 | DW_EH_PE_indirect,
+- DW.ref.__gcc_personality_v0)
+- cfi_lsda(DW_EH_PE_pcrel | DW_EH_PE_sdata4, .LexceptSTART)
+-#else
+- cfi_personality(DW_EH_PE_udata4, __gcc_personality_v0)
+- cfi_lsda(DW_EH_PE_udata4, .LexceptSTART)
+-#endif
+-
+- pushl %ebp
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%ebp, 0)
+- pushl %edi
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%edi, 0)
+- pushl %esi
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%esi, 0)
+- pushl %ebx
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%ebx, 0)
+-
+- movl 20(%esp), %ebx
+- movl 28(%esp), %ebp
+-
+- LIBC_PROBE (cond_timedwait, 3, %ebx, 24(%esp), %ebp)
+-
+- cmpl $1000000000, 4(%ebp)
+- movl $EINVAL, %eax
+- jae 18f
+-
+- /* Stack frame:
+-
+- esp + 32
+- +--------------------------+
+- esp + 24 | timeout value |
+- +--------------------------+
+- esp + 20 | futex pointer |
+- +--------------------------+
+- esp + 16 | pi-requeued flag |
+- +--------------------------+
+- esp + 12 | old broadcast_seq value |
+- +--------------------------+
+- esp + 4 | old wake_seq value |
+- +--------------------------+
+- esp + 0 | old cancellation mode |
+- +--------------------------+
+- */
+-
+-#ifndef __ASSUME_FUTEX_CLOCK_REALTIME
+-# ifdef PIC
+- LOAD_PIC_REG (cx)
+- cmpl $0, __have_futex_clock_realtime at GOTOFF(%ecx)
+-# else
+- cmpl $0, __have_futex_clock_realtime
+-# endif
+- je .Lreltmo
+-#endif
+-
+- /* Get internal lock. */
+- movl $1, %edx
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %edx, (%ebx)
+-#else
+- cmpxchgl %edx, cond_lock(%ebx)
+-#endif
+- jnz 1f
+-
+- /* Store the reference to the mutex. If there is already a
+- different value in there this is a bad user bug. */
+-2: cmpl $-1, dep_mutex(%ebx)
+- movl 24(%esp), %eax
+- je 17f
+- movl %eax, dep_mutex(%ebx)
+-
+- /* Unlock the mutex. */
+-17: xorl %edx, %edx
+- call __pthread_mutex_unlock_usercnt
+-
+- testl %eax, %eax
+- jne 16f
+-
+- addl $1, total_seq(%ebx)
+- adcl $0, total_seq+4(%ebx)
+- addl $1, cond_futex(%ebx)
+- addl $(1 << nwaiters_shift), cond_nwaiters(%ebx)
+-
+-#ifdef __ASSUME_FUTEX_CLOCK_REALTIME
+-# define FRAME_SIZE 24
+-#else
+-# define FRAME_SIZE 32
+-#endif
+- subl $FRAME_SIZE, %esp
+- cfi_adjust_cfa_offset(FRAME_SIZE)
+- cfi_remember_state
+-
+- /* Get and store current wakeup_seq value. */
+- movl wakeup_seq(%ebx), %edi
+- movl wakeup_seq+4(%ebx), %edx
+- movl broadcast_seq(%ebx), %eax
+- movl %edi, 4(%esp)
+- movl %edx, 8(%esp)
+- movl %eax, 12(%esp)
+-
+- /* Reset the pi-requeued flag. */
+- movl $0, 16(%esp)
+-
+- cmpl $0, (%ebp)
+- movl $-ETIMEDOUT, %esi
+- js 6f
+-
+-8: movl cond_futex(%ebx), %edi
+- movl %edi, 20(%esp)
+-
+- /* Unlock. */
+- LOCK
+-#if cond_lock == 0
+- subl $1, (%ebx)
+-#else
+- subl $1, cond_lock(%ebx)
+-#endif
+- jne 3f
+-
+-.LcleanupSTART:
+-4: call __pthread_enable_asynccancel
+- movl %eax, (%esp)
+-
+- leal (%ebp), %esi
+-#if FUTEX_PRIVATE_FLAG > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- sete %cl
+- je 40f
+-
+- movl dep_mutex(%ebx), %edi
+- /* Requeue to a non-robust PI mutex if the PI bit is set and
+- the robust bit is not set. */
+- movl MUTEX_KIND(%edi), %eax
+- andl $(ROBUST_BIT|PI_BIT), %eax
+- cmpl $PI_BIT, %eax
+- jne 40f
+-
+- movl $(FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG), %ecx
+- /* The following only works like this because we only support
+- two clocks, represented using a single bit. */
+- testl $1, cond_nwaiters(%ebx)
+- /* XXX Need to implement using sete instead of a jump. */
+- jne 42f
+- orl $FUTEX_CLOCK_REALTIME, %ecx
+-
+-42: movl 20(%esp), %edx
+- addl $cond_futex, %ebx
+-.Ladd_cond_futex_pi:
+- movl $SYS_futex, %eax
+- ENTER_KERNEL
+- subl $cond_futex, %ebx
+-.Lsub_cond_futex_pi:
+- movl %eax, %esi
+- /* Set the pi-requeued flag only if the kernel has returned 0. The
+- kernel does not hold the mutex on ETIMEDOUT or any other error. */
+- cmpl $0, %eax
+- sete 16(%esp)
+- je 41f
+-
+- /* When a futex syscall with FUTEX_WAIT_REQUEUE_PI returns
+- successfully, it has already locked the mutex for us and the
+- pi_flag (16(%esp)) is set to denote that fact. However, if another
+- thread changed the futex value before we entered the wait, the
+- syscall may return an EAGAIN and the mutex is not locked. We go
+- ahead with a success anyway since later we look at the pi_flag to
+- decide if we got the mutex or not. The sequence numbers then make
+- sure that only one of the threads actually wake up. We retry using
+- normal FUTEX_WAIT only if the kernel returned ENOSYS, since normal
+- and PI futexes don't mix.
+-
+- Note that we don't check for EAGAIN specifically; we assume that the
+- only other error the futex function could return is EAGAIN (barring
+- the ETIMEOUT of course, for the timeout case in futex) since
+- anything else would mean an error in our function. It is too
+- expensive to do that check for every call (which is quite common in
+- case of a large number of threads), so it has been skipped. */
+- cmpl $-ENOSYS, %eax
+- jne 41f
+- xorl %ecx, %ecx
+-
+-40: subl $1, %ecx
+- movl $0, 16(%esp)
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+- addl $FUTEX_WAIT_BITSET, %ecx
+- /* The following only works like this because we only support
+- two clocks, represented using a single bit. */
+- testl $1, cond_nwaiters(%ebx)
+- jne 30f
+- orl $FUTEX_CLOCK_REALTIME, %ecx
+-30:
+- movl 20(%esp), %edx
+- movl $0xffffffff, %ebp
+- addl $cond_futex, %ebx
+-.Ladd_cond_futex:
+- movl $SYS_futex, %eax
+- ENTER_KERNEL
+- subl $cond_futex, %ebx
+-.Lsub_cond_futex:
+- movl 28+FRAME_SIZE(%esp), %ebp
+- movl %eax, %esi
+-
+-41: movl (%esp), %eax
+- call __pthread_disable_asynccancel
+-.LcleanupEND:
+-
+- /* Lock. */
+- movl $1, %edx
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %edx, (%ebx)
+-#else
+- cmpxchgl %edx, cond_lock(%ebx)
+-#endif
+- jnz 5f
+-
+-6: movl broadcast_seq(%ebx), %eax
+- cmpl 12(%esp), %eax
+- jne 23f
+-
+- movl woken_seq(%ebx), %eax
+- movl woken_seq+4(%ebx), %ecx
+-
+- movl wakeup_seq(%ebx), %edi
+- movl wakeup_seq+4(%ebx), %edx
+-
+- cmpl 8(%esp), %edx
+- jne 7f
+- cmpl 4(%esp), %edi
+- je 15f
+-
+-7: cmpl %ecx, %edx
+- jne 9f
+- cmp %eax, %edi
+- jne 9f
+-
+-15: cmpl $-ETIMEDOUT, %esi
+- je 28f
+-
+- /* We need to go back to futex_wait. If we're using requeue_pi, then
+- release the mutex we had acquired and go back. */
+- movl 16(%esp), %edx
+- test %edx, %edx
+- jz 8b
+-
+- /* Adjust the mutex values first and then unlock it. The unlock
+- should always succeed or else the kernel did not lock the mutex
+- correctly. */
+- movl dep_mutex(%ebx), %eax
+- call __pthread_mutex_cond_lock_adjust
+- movl dep_mutex(%ebx), %eax
+- xorl %edx, %edx
+- call __pthread_mutex_unlock_usercnt
+- jmp 8b
+-
+-28: addl $1, wakeup_seq(%ebx)
+- adcl $0, wakeup_seq+4(%ebx)
+- addl $1, cond_futex(%ebx)
+- movl $ETIMEDOUT, %esi
+- jmp 14f
+-
+-23: xorl %esi, %esi
+- jmp 24f
+-
+-9: xorl %esi, %esi
+-14: addl $1, woken_seq(%ebx)
+- adcl $0, woken_seq+4(%ebx)
+-
+-24: subl $(1 << nwaiters_shift), cond_nwaiters(%ebx)
+-
+- /* Wake up a thread which wants to destroy the condvar object. */
+- movl total_seq(%ebx), %eax
+- andl total_seq+4(%ebx), %eax
+- cmpl $0xffffffff, %eax
+- jne 25f
+- movl cond_nwaiters(%ebx), %eax
+- andl $~((1 << nwaiters_shift) - 1), %eax
+- jne 25f
+-
+- addl $cond_nwaiters, %ebx
+- movl $SYS_futex, %eax
+-#if FUTEX_PRIVATE_FLAG > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_nwaiters(%ebx)
+- sete %cl
+- subl $1, %ecx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+- addl $FUTEX_WAKE, %ecx
+- movl $1, %edx
+- ENTER_KERNEL
+- subl $cond_nwaiters, %ebx
+-
+-25: LOCK
+-#if cond_lock == 0
+- subl $1, (%ebx)
+-#else
+- subl $1, cond_lock(%ebx)
+-#endif
+- jne 10f
+-
+-11: movl 24+FRAME_SIZE(%esp), %eax
+- /* With requeue_pi, the mutex lock is held in the kernel. */
+- movl 16(%esp), %ecx
+- testl %ecx, %ecx
+- jnz 27f
+-
+- call __pthread_mutex_cond_lock
+-26: addl $FRAME_SIZE, %esp
+- cfi_adjust_cfa_offset(-FRAME_SIZE)
+-
+- /* We return the result of the mutex_lock operation if it failed. */
+- testl %eax, %eax
+-#ifdef HAVE_CMOV
+- cmovel %esi, %eax
+-#else
+- jne 22f
+- movl %esi, %eax
+-22:
+-#endif
+-
+-18: popl %ebx
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%ebx)
+- popl %esi
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%esi)
+- popl %edi
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%edi)
+- popl %ebp
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%ebp)
+-
+- ret
+-
+- cfi_restore_state
+-
+-27: call __pthread_mutex_cond_lock_adjust
+- xorl %eax, %eax
+- jmp 26b
+-
+- cfi_adjust_cfa_offset(-FRAME_SIZE);
+- /* Initial locking failed. */
+-1:
+-#if cond_lock == 0
+- movl %ebx, %edx
+-#else
+- leal cond_lock(%ebx), %edx
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_lock_wait
+- jmp 2b
+-
+- /* The initial unlocking of the mutex failed. */
+-16:
+- LOCK
+-#if cond_lock == 0
+- subl $1, (%ebx)
+-#else
+- subl $1, cond_lock(%ebx)
+-#endif
+- jne 18b
+-
+- movl %eax, %esi
+-#if cond_lock == 0
+- movl %ebx, %eax
+-#else
+- leal cond_lock(%ebx), %eax
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+-
+- movl %esi, %eax
+- jmp 18b
+-
+- cfi_adjust_cfa_offset(FRAME_SIZE)
+-
+- /* Unlock in loop requires wakeup. */
+-3:
+-#if cond_lock == 0
+- movl %ebx, %eax
+-#else
+- leal cond_lock(%ebx), %eax
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+- jmp 4b
+-
+- /* Locking in loop failed. */
+-5:
+-#if cond_lock == 0
+- movl %ebx, %edx
+-#else
+- leal cond_lock(%ebx), %edx
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_lock_wait
+- jmp 6b
+-
+- /* Unlock after loop requires wakeup. */
+-10:
+-#if cond_lock == 0
+- movl %ebx, %eax
+-#else
+- leal cond_lock(%ebx), %eax
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+- jmp 11b
+-
+-#ifndef __ASSUME_FUTEX_CLOCK_REALTIME
+- cfi_adjust_cfa_offset(-FRAME_SIZE)
+-.Lreltmo:
+- /* Get internal lock. */
+- movl $1, %edx
+- xorl %eax, %eax
+- LOCK
+-# if cond_lock == 0
+- cmpxchgl %edx, (%ebx)
+-# else
+- cmpxchgl %edx, cond_lock(%ebx)
+-# endif
+- jnz 101f
+-
+- /* Store the reference to the mutex. If there is already a
+- different value in there this is a bad user bug. */
+-102: cmpl $-1, dep_mutex(%ebx)
+- movl 24(%esp), %eax
+- je 117f
+- movl %eax, dep_mutex(%ebx)
+-
+- /* Unlock the mutex. */
+-117: xorl %edx, %edx
+- call __pthread_mutex_unlock_usercnt
+-
+- testl %eax, %eax
+- jne 16b
+-
+- addl $1, total_seq(%ebx)
+- adcl $0, total_seq+4(%ebx)
+- addl $1, cond_futex(%ebx)
+- addl $(1 << nwaiters_shift), cond_nwaiters(%ebx)
+-
+- subl $FRAME_SIZE, %esp
+- cfi_adjust_cfa_offset(FRAME_SIZE)
+-
+- /* Get and store current wakeup_seq value. */
+- movl wakeup_seq(%ebx), %edi
+- movl wakeup_seq+4(%ebx), %edx
+- movl broadcast_seq(%ebx), %eax
+- movl %edi, 4(%esp)
+- movl %edx, 8(%esp)
+- movl %eax, 12(%esp)
+-
+- /* Reset the pi-requeued flag. */
+- movl $0, 16(%esp)
+-
+- /* Get the current time. */
+-108: movl %ebx, %edx
+-# ifdef __NR_clock_gettime
+- /* Get the clock number. */
+- movl cond_nwaiters(%ebx), %ebx
+- andl $((1 << nwaiters_shift) - 1), %ebx
+- /* Only clocks 0 and 1 are allowed so far. Both are handled in the
+- kernel. */
+- leal 24(%esp), %ecx
+- movl $__NR_clock_gettime, %eax
+- ENTER_KERNEL
+- movl %edx, %ebx
+-
+- /* Compute relative timeout. */
+- movl (%ebp), %ecx
+- movl 4(%ebp), %edx
+- subl 24(%esp), %ecx
+- subl 28(%esp), %edx
+-# else
+- /* Get the current time. */
+- leal 24(%esp), %ebx
+- xorl %ecx, %ecx
+- movl $__NR_gettimeofday, %eax
+- ENTER_KERNEL
+- movl %edx, %ebx
+-
+- /* Compute relative timeout. */
+- movl 28(%esp), %eax
+- movl $1000, %edx
+- mul %edx /* Milli seconds to nano seconds. */
+- movl (%ebp), %ecx
+- movl 4(%ebp), %edx
+- subl 24(%esp), %ecx
+- subl %eax, %edx
+-# endif
+- jns 112f
+- addl $1000000000, %edx
+- subl $1, %ecx
+-112: testl %ecx, %ecx
+- movl $-ETIMEDOUT, %esi
+- js 106f
+-
+- /* Store relative timeout. */
+-121: movl %ecx, 24(%esp)
+- movl %edx, 28(%esp)
+-
+- movl cond_futex(%ebx), %edi
+- movl %edi, 20(%esp)
+-
+- /* Unlock. */
+- LOCK
+-# if cond_lock == 0
+- subl $1, (%ebx)
+-# else
+- subl $1, cond_lock(%ebx)
+-# endif
+- jne 103f
+-
+-.LcleanupSTART2:
+-104: call __pthread_enable_asynccancel
+- movl %eax, (%esp)
+-
+- leal 24(%esp), %esi
+-# if FUTEX_PRIVATE_FLAG > 255
+- xorl %ecx, %ecx
+-# endif
+- cmpl $-1, dep_mutex(%ebx)
+- sete %cl
+- subl $1, %ecx
+-# ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-# else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-# endif
+-# if FUTEX_WAIT != 0
+- addl $FUTEX_WAIT, %ecx
+-# endif
+- movl 20(%esp), %edx
+- addl $cond_futex, %ebx
+-.Ladd_cond_futex2:
+- movl $SYS_futex, %eax
+- ENTER_KERNEL
+- subl $cond_futex, %ebx
+-.Lsub_cond_futex2:
+- movl %eax, %esi
+-
+-141: movl (%esp), %eax
+- call __pthread_disable_asynccancel
+-.LcleanupEND2:
+-
+-
+- /* Lock. */
+- movl $1, %edx
+- xorl %eax, %eax
+- LOCK
+-# if cond_lock == 0
+- cmpxchgl %edx, (%ebx)
+-# else
+- cmpxchgl %edx, cond_lock(%ebx)
+-# endif
+- jnz 105f
+-
+-106: movl broadcast_seq(%ebx), %eax
+- cmpl 12(%esp), %eax
+- jne 23b
+-
+- movl woken_seq(%ebx), %eax
+- movl woken_seq+4(%ebx), %ecx
+-
+- movl wakeup_seq(%ebx), %edi
+- movl wakeup_seq+4(%ebx), %edx
+-
+- cmpl 8(%esp), %edx
+- jne 107f
+- cmpl 4(%esp), %edi
+- je 115f
+-
+-107: cmpl %ecx, %edx
+- jne 9b
+- cmp %eax, %edi
+- jne 9b
+-
+-115: cmpl $-ETIMEDOUT, %esi
+- je 28b
+-
+- jmp 8b
+-
+- cfi_adjust_cfa_offset(-FRAME_SIZE)
+- /* Initial locking failed. */
+-101:
+-# if cond_lock == 0
+- movl %ebx, %edx
+-# else
+- leal cond_lock(%ebx), %edx
+-# endif
+-# if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-# endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-# if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-# endif
+- call __lll_lock_wait
+- jmp 102b
+-
+- cfi_adjust_cfa_offset(FRAME_SIZE)
+-
+- /* Unlock in loop requires wakeup. */
+-103:
+-# if cond_lock == 0
+- movl %ebx, %eax
+-# else
+- leal cond_lock(%ebx), %eax
+-# endif
+-# if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-# endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-# if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-# endif
+- call __lll_unlock_wake
+- jmp 104b
+-
+- /* Locking in loop failed. */
+-105:
+-# if cond_lock == 0
+- movl %ebx, %edx
+-# else
+- leal cond_lock(%ebx), %edx
+-# endif
+-# if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-# endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-# if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-# endif
+- call __lll_lock_wait
+- jmp 106b
+-#endif
+-
+- .size __pthread_cond_timedwait, .-__pthread_cond_timedwait
+-versioned_symbol (libpthread, __pthread_cond_timedwait, pthread_cond_timedwait,
+- GLIBC_2_3_2)
+-
+-
+- .type __condvar_tw_cleanup2, @function
+-__condvar_tw_cleanup2:
+- subl $cond_futex, %ebx
+- .size __condvar_tw_cleanup2, .-__condvar_tw_cleanup2
+- .type __condvar_tw_cleanup, @function
+-__condvar_tw_cleanup:
+- movl %eax, %esi
+-
+- /* Get internal lock. */
+- movl $1, %edx
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %edx, (%ebx)
+-#else
+- cmpxchgl %edx, cond_lock(%ebx)
+-#endif
+- jz 1f
+-
+-#if cond_lock == 0
+- movl %ebx, %edx
+-#else
+- leal cond_lock(%ebx), %edx
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_lock_wait
+-
+-1: movl broadcast_seq(%ebx), %eax
+- cmpl 12(%esp), %eax
+- jne 3f
+-
+- /* We increment the wakeup_seq counter only if it is lower than
+- total_seq. If this is not the case the thread was woken and
+- then canceled. In this case we ignore the signal. */
+- movl total_seq(%ebx), %eax
+- movl total_seq+4(%ebx), %edi
+- cmpl wakeup_seq+4(%ebx), %edi
+- jb 6f
+- ja 7f
+- cmpl wakeup_seq(%ebx), %eax
+- jbe 7f
+-
+-6: addl $1, wakeup_seq(%ebx)
+- adcl $0, wakeup_seq+4(%ebx)
+- addl $1, cond_futex(%ebx)
+-
+-7: addl $1, woken_seq(%ebx)
+- adcl $0, woken_seq+4(%ebx)
+-
+-3: subl $(1 << nwaiters_shift), cond_nwaiters(%ebx)
+-
+- /* Wake up a thread which wants to destroy the condvar object. */
+- xorl %edi, %edi
+- movl total_seq(%ebx), %eax
+- andl total_seq+4(%ebx), %eax
+- cmpl $0xffffffff, %eax
+- jne 4f
+- movl cond_nwaiters(%ebx), %eax
+- andl $~((1 << nwaiters_shift) - 1), %eax
+- jne 4f
+-
+- addl $cond_nwaiters, %ebx
+- movl $SYS_futex, %eax
+-#if FUTEX_PRIVATE_FLAG > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_nwaiters(%ebx)
+- sete %cl
+- subl $1, %ecx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+- addl $FUTEX_WAKE, %ecx
+- movl $1, %edx
+- ENTER_KERNEL
+- subl $cond_nwaiters, %ebx
+- movl $1, %edi
+-
+-4: LOCK
+-#if cond_lock == 0
+- subl $1, (%ebx)
+-#else
+- subl $1, cond_lock(%ebx)
+-#endif
+- je 2f
+-
+-#if cond_lock == 0
+- movl %ebx, %eax
+-#else
+- leal cond_lock(%ebx), %eax
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+-
+- /* Wake up all waiters to make sure no signal gets lost. */
+-2: testl %edi, %edi
+- jnz 5f
+- addl $cond_futex, %ebx
+-#if FUTEX_PRIVATE_FLAG > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_futex(%ebx)
+- sete %cl
+- subl $1, %ecx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+- addl $FUTEX_WAKE, %ecx
+- movl $SYS_futex, %eax
+- movl $0x7fffffff, %edx
+- ENTER_KERNEL
+-
+- /* Lock the mutex only if we don't own it already. This only happens
+- in case of PI mutexes, if we got cancelled after a successful
+- return of the futex syscall and before disabling async
+- cancellation. */
+-5: movl 24+FRAME_SIZE(%esp), %eax
+- movl MUTEX_KIND(%eax), %ebx
+- andl $(ROBUST_BIT|PI_BIT), %ebx
+- cmpl $PI_BIT, %ebx
+- jne 8f
+-
+- movl (%eax), %ebx
+- andl $TID_MASK, %ebx
+- cmpl %ebx, %gs:TID
+- jne 8f
+- /* We managed to get the lock. Fix it up before returning. */
+- call __pthread_mutex_cond_lock_adjust
+- jmp 9f
+-
+-8: call __pthread_mutex_cond_lock
+-
+-9: movl %esi, (%esp)
+-.LcallUR:
+- call _Unwind_Resume
+- hlt
+-.LENDCODE:
+- cfi_endproc
+- .size __condvar_tw_cleanup, .-__condvar_tw_cleanup
+-
+-
+- .section .gcc_except_table,"a", at progbits
+-.LexceptSTART:
+- .byte DW_EH_PE_omit # @LPStart format (omit)
+- .byte DW_EH_PE_omit # @TType format (omit)
+- .byte DW_EH_PE_sdata4 # call-site format
+- # DW_EH_PE_sdata4
+- .uleb128 .Lcstend-.Lcstbegin
+-.Lcstbegin:
+- .long .LcleanupSTART-.LSTARTCODE
+- .long .Ladd_cond_futex_pi-.LcleanupSTART
+- .long __condvar_tw_cleanup-.LSTARTCODE
+- .uleb128 0
+- .long .Ladd_cond_futex_pi-.LSTARTCODE
+- .long .Lsub_cond_futex_pi-.Ladd_cond_futex_pi
+- .long __condvar_tw_cleanup2-.LSTARTCODE
+- .uleb128 0
+- .long .Lsub_cond_futex_pi-.LSTARTCODE
+- .long .Ladd_cond_futex-.Lsub_cond_futex_pi
+- .long __condvar_tw_cleanup-.LSTARTCODE
+- .uleb128 0
+- .long .Ladd_cond_futex-.LSTARTCODE
+- .long .Lsub_cond_futex-.Ladd_cond_futex
+- .long __condvar_tw_cleanup2-.LSTARTCODE
+- .uleb128 0
+- .long .Lsub_cond_futex-.LSTARTCODE
+- .long .LcleanupEND-.Lsub_cond_futex
+- .long __condvar_tw_cleanup-.LSTARTCODE
+- .uleb128 0
+-#ifndef __ASSUME_FUTEX_CLOCK_REALTIME
+- .long .LcleanupSTART2-.LSTARTCODE
+- .long .Ladd_cond_futex2-.LcleanupSTART2
+- .long __condvar_tw_cleanup-.LSTARTCODE
+- .uleb128 0
+- .long .Ladd_cond_futex2-.LSTARTCODE
+- .long .Lsub_cond_futex2-.Ladd_cond_futex2
+- .long __condvar_tw_cleanup2-.LSTARTCODE
+- .uleb128 0
+- .long .Lsub_cond_futex2-.LSTARTCODE
+- .long .LcleanupEND2-.Lsub_cond_futex2
+- .long __condvar_tw_cleanup-.LSTARTCODE
+- .uleb128 0
+-#endif
+- .long .LcallUR-.LSTARTCODE
+- .long .LENDCODE-.LcallUR
+- .long 0
+- .uleb128 0
+-.Lcstend:
+-
+-
+-#ifdef SHARED
+- .hidden DW.ref.__gcc_personality_v0
+- .weak DW.ref.__gcc_personality_v0
+- .section .gnu.linkonce.d.DW.ref.__gcc_personality_v0,"aw", at progbits
+- .align 4
+- .type DW.ref.__gcc_personality_v0, @object
+- .size DW.ref.__gcc_personality_v0, 4
+-DW.ref.__gcc_personality_v0:
+- .long __gcc_personality_v0
+-#endif
+diff --git a/sysdeps/unix/sysv/linux/i386/pthread_cond_wait.S b/sysdeps/unix/sysv/linux/i386/pthread_cond_wait.S
+deleted file mode 100644
+index 5016718..0000000
+--- a/sysdeps/unix/sysv/linux/i386/pthread_cond_wait.S
++++ /dev/null
+@@ -1,642 +0,0 @@
+-/* Copyright (C) 2002-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Ulrich Drepper <drepper at redhat.com>, 2002.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library; if not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#include <sysdep.h>
+-#include <shlib-compat.h>
+-#include <lowlevellock.h>
+-#include <lowlevelcond.h>
+-#include <tcb-offsets.h>
+-#include <pthread-errnos.h>
+-#include <pthread-pi-defines.h>
+-#include <kernel-features.h>
+-#include <stap-probe.h>
+-
+-
+- .text
+-
+-/* int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex) */
+- .globl __pthread_cond_wait
+- .type __pthread_cond_wait, @function
+- .align 16
+-__pthread_cond_wait:
+-.LSTARTCODE:
+- cfi_startproc
+-#ifdef SHARED
+- cfi_personality(DW_EH_PE_pcrel | DW_EH_PE_sdata4 | DW_EH_PE_indirect,
+- DW.ref.__gcc_personality_v0)
+- cfi_lsda(DW_EH_PE_pcrel | DW_EH_PE_sdata4, .LexceptSTART)
+-#else
+- cfi_personality(DW_EH_PE_udata4, __gcc_personality_v0)
+- cfi_lsda(DW_EH_PE_udata4, .LexceptSTART)
+-#endif
+-
+- pushl %ebp
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%ebp, 0)
+- pushl %edi
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%edi, 0)
+- pushl %esi
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%esi, 0)
+- pushl %ebx
+- cfi_adjust_cfa_offset(4)
+- cfi_rel_offset(%ebx, 0)
+-
+- xorl %esi, %esi
+- movl 20(%esp), %ebx
+-
+- LIBC_PROBE (cond_wait, 2, 24(%esp), %ebx)
+-
+- /* Get internal lock. */
+- movl $1, %edx
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %edx, (%ebx)
+-#else
+- cmpxchgl %edx, cond_lock(%ebx)
+-#endif
+- jnz 1f
+-
+- /* Store the reference to the mutex. If there is already a
+- different value in there this is a bad user bug. */
+-2: cmpl $-1, dep_mutex(%ebx)
+- movl 24(%esp), %eax
+- je 15f
+- movl %eax, dep_mutex(%ebx)
+-
+- /* Unlock the mutex. */
+-15: xorl %edx, %edx
+- call __pthread_mutex_unlock_usercnt
+-
+- testl %eax, %eax
+- jne 12f
+-
+- addl $1, total_seq(%ebx)
+- adcl $0, total_seq+4(%ebx)
+- addl $1, cond_futex(%ebx)
+- addl $(1 << nwaiters_shift), cond_nwaiters(%ebx)
+-
+-#define FRAME_SIZE 20
+- subl $FRAME_SIZE, %esp
+- cfi_adjust_cfa_offset(FRAME_SIZE)
+- cfi_remember_state
+-
+- /* Get and store current wakeup_seq value. */
+- movl wakeup_seq(%ebx), %edi
+- movl wakeup_seq+4(%ebx), %edx
+- movl broadcast_seq(%ebx), %eax
+- movl %edi, 4(%esp)
+- movl %edx, 8(%esp)
+- movl %eax, 12(%esp)
+-
+- /* Reset the pi-requeued flag. */
+-8: movl $0, 16(%esp)
+- movl cond_futex(%ebx), %ebp
+-
+- /* Unlock. */
+- LOCK
+-#if cond_lock == 0
+- subl $1, (%ebx)
+-#else
+- subl $1, cond_lock(%ebx)
+-#endif
+- jne 3f
+-
+-.LcleanupSTART:
+-4: call __pthread_enable_asynccancel
+- movl %eax, (%esp)
+-
+- xorl %ecx, %ecx
+- cmpl $-1, dep_mutex(%ebx)
+- sete %cl
+- je 18f
+-
+- movl dep_mutex(%ebx), %edi
+- /* Requeue to a non-robust PI mutex if the PI bit is set and
+- the robust bit is not set. */
+- movl MUTEX_KIND(%edi), %eax
+- andl $(ROBUST_BIT|PI_BIT), %eax
+- cmpl $PI_BIT, %eax
+- jne 18f
+-
+- movl $(FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG), %ecx
+- movl %ebp, %edx
+- xorl %esi, %esi
+- addl $cond_futex, %ebx
+-.Ladd_cond_futex_pi:
+- movl $SYS_futex, %eax
+- ENTER_KERNEL
+- subl $cond_futex, %ebx
+-.Lsub_cond_futex_pi:
+- /* Set the pi-requeued flag only if the kernel has returned 0. The
+- kernel does not hold the mutex on error. */
+- cmpl $0, %eax
+- sete 16(%esp)
+- je 19f
+-
+- /* When a futex syscall with FUTEX_WAIT_REQUEUE_PI returns
+- successfully, it has already locked the mutex for us and the
+- pi_flag (16(%esp)) is set to denote that fact. However, if another
+- thread changed the futex value before we entered the wait, the
+- syscall may return an EAGAIN and the mutex is not locked. We go
+- ahead with a success anyway since later we look at the pi_flag to
+- decide if we got the mutex or not. The sequence numbers then make
+- sure that only one of the threads actually wake up. We retry using
+- normal FUTEX_WAIT only if the kernel returned ENOSYS, since normal
+- and PI futexes don't mix.
+-
+- Note that we don't check for EAGAIN specifically; we assume that the
+- only other error the futex function could return is EAGAIN since
+- anything else would mean an error in our function. It is too
+- expensive to do that check for every call (which is quite common in
+- case of a large number of threads), so it has been skipped. */
+- cmpl $-ENOSYS, %eax
+- jne 19f
+- xorl %ecx, %ecx
+-
+-18: subl $1, %ecx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+-#if FUTEX_WAIT != 0
+- addl $FUTEX_WAIT, %ecx
+-#endif
+- movl %ebp, %edx
+- addl $cond_futex, %ebx
+-.Ladd_cond_futex:
+- movl $SYS_futex, %eax
+- ENTER_KERNEL
+- subl $cond_futex, %ebx
+-.Lsub_cond_futex:
+-
+-19: movl (%esp), %eax
+- call __pthread_disable_asynccancel
+-.LcleanupEND:
+-
+- /* Lock. */
+- movl $1, %edx
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %edx, (%ebx)
+-#else
+- cmpxchgl %edx, cond_lock(%ebx)
+-#endif
+- jnz 5f
+-
+-6: movl broadcast_seq(%ebx), %eax
+- cmpl 12(%esp), %eax
+- jne 16f
+-
+- movl woken_seq(%ebx), %eax
+- movl woken_seq+4(%ebx), %ecx
+-
+- movl wakeup_seq(%ebx), %edi
+- movl wakeup_seq+4(%ebx), %edx
+-
+- cmpl 8(%esp), %edx
+- jne 7f
+- cmpl 4(%esp), %edi
+- je 22f
+-
+-7: cmpl %ecx, %edx
+- jne 9f
+- cmp %eax, %edi
+- je 22f
+-
+-9: addl $1, woken_seq(%ebx)
+- adcl $0, woken_seq+4(%ebx)
+-
+- /* Unlock */
+-16: subl $(1 << nwaiters_shift), cond_nwaiters(%ebx)
+-
+- /* Wake up a thread which wants to destroy the condvar object. */
+- movl total_seq(%ebx), %eax
+- andl total_seq+4(%ebx), %eax
+- cmpl $0xffffffff, %eax
+- jne 17f
+- movl cond_nwaiters(%ebx), %eax
+- andl $~((1 << nwaiters_shift) - 1), %eax
+- jne 17f
+-
+- addl $cond_nwaiters, %ebx
+- movl $SYS_futex, %eax
+-#if FUTEX_PRIVATE_FLAG > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_nwaiters(%ebx)
+- sete %cl
+- subl $1, %ecx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+- addl $FUTEX_WAKE, %ecx
+- movl $1, %edx
+- ENTER_KERNEL
+- subl $cond_nwaiters, %ebx
+-
+-17: LOCK
+-#if cond_lock == 0
+- subl $1, (%ebx)
+-#else
+- subl $1, cond_lock(%ebx)
+-#endif
+- jne 10f
+-
+- /* With requeue_pi, the mutex lock is held in the kernel. */
+-11: movl 24+FRAME_SIZE(%esp), %eax
+- movl 16(%esp), %ecx
+- testl %ecx, %ecx
+- jnz 21f
+-
+- call __pthread_mutex_cond_lock
+-20: addl $FRAME_SIZE, %esp
+- cfi_adjust_cfa_offset(-FRAME_SIZE);
+-
+-14: popl %ebx
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%ebx)
+- popl %esi
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%esi)
+- popl %edi
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%edi)
+- popl %ebp
+- cfi_adjust_cfa_offset(-4)
+- cfi_restore(%ebp)
+-
+- /* We return the result of the mutex_lock operation. */
+- ret
+-
+- cfi_restore_state
+-
+-21: call __pthread_mutex_cond_lock_adjust
+- xorl %eax, %eax
+- jmp 20b
+-
+- cfi_adjust_cfa_offset(-FRAME_SIZE);
+-
+- /* We need to go back to futex_wait. If we're using requeue_pi, then
+- release the mutex we had acquired and go back. */
+-22: movl 16(%esp), %edx
+- test %edx, %edx
+- jz 8b
+-
+- /* Adjust the mutex values first and then unlock it. The unlock
+- should always succeed or else the kernel did not lock the mutex
+- correctly. */
+- movl dep_mutex(%ebx), %eax
+- call __pthread_mutex_cond_lock_adjust
+- movl dep_mutex(%ebx), %eax
+- xorl %edx, %edx
+- call __pthread_mutex_unlock_usercnt
+- jmp 8b
+-
+- /* Initial locking failed. */
+-1:
+-#if cond_lock == 0
+- movl %ebx, %edx
+-#else
+- leal cond_lock(%ebx), %edx
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_lock_wait
+- jmp 2b
+-
+- /* The initial unlocking of the mutex failed. */
+-12:
+- LOCK
+-#if cond_lock == 0
+- subl $1, (%ebx)
+-#else
+- subl $1, cond_lock(%ebx)
+-#endif
+- jne 14b
+-
+- movl %eax, %esi
+-#if cond_lock == 0
+- movl %ebx, %eax
+-#else
+- leal cond_lock(%ebx), %eax
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+-
+- movl %esi, %eax
+- jmp 14b
+-
+- cfi_adjust_cfa_offset(FRAME_SIZE)
+-
+- /* Unlock in loop requires wakeup. */
+-3:
+-#if cond_lock == 0
+- movl %ebx, %eax
+-#else
+- leal cond_lock(%ebx), %eax
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+- jmp 4b
+-
+- /* Locking in loop failed. */
+-5:
+-#if cond_lock == 0
+- movl %ebx, %edx
+-#else
+- leal cond_lock(%ebx), %edx
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_lock_wait
+- jmp 6b
+-
+- /* Unlock after loop requires wakeup. */
+-10:
+-#if cond_lock == 0
+- movl %ebx, %eax
+-#else
+- leal cond_lock(%ebx), %eax
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+- jmp 11b
+-
+- .size __pthread_cond_wait, .-__pthread_cond_wait
+-versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait,
+- GLIBC_2_3_2)
+-
+-
+- .type __condvar_w_cleanup2, @function
+-__condvar_w_cleanup2:
+- subl $cond_futex, %ebx
+- .size __condvar_w_cleanup2, .-__condvar_w_cleanup2
+-.LSbl4:
+- .type __condvar_w_cleanup, @function
+-__condvar_w_cleanup:
+- movl %eax, %esi
+-
+- /* Get internal lock. */
+- movl $1, %edx
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %edx, (%ebx)
+-#else
+- cmpxchgl %edx, cond_lock(%ebx)
+-#endif
+- jz 1f
+-
+-#if cond_lock == 0
+- movl %ebx, %edx
+-#else
+- leal cond_lock(%ebx), %edx
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_lock_wait
+-
+-1: movl broadcast_seq(%ebx), %eax
+- cmpl 12(%esp), %eax
+- jne 3f
+-
+- /* We increment the wakeup_seq counter only if it is lower than
+- total_seq. If this is not the case the thread was woken and
+- then canceled. In this case we ignore the signal. */
+- movl total_seq(%ebx), %eax
+- movl total_seq+4(%ebx), %edi
+- cmpl wakeup_seq+4(%ebx), %edi
+- jb 6f
+- ja 7f
+- cmpl wakeup_seq(%ebx), %eax
+- jbe 7f
+-
+-6: addl $1, wakeup_seq(%ebx)
+- adcl $0, wakeup_seq+4(%ebx)
+- addl $1, cond_futex(%ebx)
+-
+-7: addl $1, woken_seq(%ebx)
+- adcl $0, woken_seq+4(%ebx)
+-
+-3: subl $(1 << nwaiters_shift), cond_nwaiters(%ebx)
+-
+- /* Wake up a thread which wants to destroy the condvar object. */
+- xorl %edi, %edi
+- movl total_seq(%ebx), %eax
+- andl total_seq+4(%ebx), %eax
+- cmpl $0xffffffff, %eax
+- jne 4f
+- movl cond_nwaiters(%ebx), %eax
+- andl $~((1 << nwaiters_shift) - 1), %eax
+- jne 4f
+-
+- addl $cond_nwaiters, %ebx
+- movl $SYS_futex, %eax
+-#if FUTEX_PRIVATE_FLAG > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_nwaiters(%ebx)
+- sete %cl
+- subl $1, %ecx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+- addl $FUTEX_WAKE, %ecx
+- movl $1, %edx
+- ENTER_KERNEL
+- subl $cond_nwaiters, %ebx
+- movl $1, %edi
+-
+-4: LOCK
+-#if cond_lock == 0
+- subl $1, (%ebx)
+-#else
+- subl $1, cond_lock(%ebx)
+-#endif
+- je 2f
+-
+-#if cond_lock == 0
+- movl %ebx, %eax
+-#else
+- leal cond_lock(%ebx), %eax
+-#endif
+-#if (LLL_SHARED-LLL_PRIVATE) > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex(%ebx)
+- setne %cl
+- subl $1, %ecx
+- andl $(LLL_SHARED-LLL_PRIVATE), %ecx
+-#if LLL_PRIVATE != 0
+- addl $LLL_PRIVATE, %ecx
+-#endif
+- call __lll_unlock_wake
+-
+- /* Wake up all waiters to make sure no signal gets lost. */
+-2: testl %edi, %edi
+- jnz 5f
+- addl $cond_futex, %ebx
+-#if FUTEX_PRIVATE_FLAG > 255
+- xorl %ecx, %ecx
+-#endif
+- cmpl $-1, dep_mutex-cond_futex(%ebx)
+- sete %cl
+- subl $1, %ecx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %ecx
+-#else
+- andl %gs:PRIVATE_FUTEX, %ecx
+-#endif
+- addl $FUTEX_WAKE, %ecx
+- movl $SYS_futex, %eax
+- movl $0x7fffffff, %edx
+- ENTER_KERNEL
+-
+- /* Lock the mutex only if we don't own it already. This only happens
+- in case of PI mutexes, if we got cancelled after a successful
+- return of the futex syscall and before disabling async
+- cancellation. */
+-5: movl 24+FRAME_SIZE(%esp), %eax
+- movl MUTEX_KIND(%eax), %ebx
+- andl $(ROBUST_BIT|PI_BIT), %ebx
+- cmpl $PI_BIT, %ebx
+- jne 8f
+-
+- movl (%eax), %ebx
+- andl $TID_MASK, %ebx
+- cmpl %ebx, %gs:TID
+- jne 8f
+- /* We managed to get the lock. Fix it up before returning. */
+- call __pthread_mutex_cond_lock_adjust
+- jmp 9f
+-
+-8: call __pthread_mutex_cond_lock
+-
+-9: movl %esi, (%esp)
+-.LcallUR:
+- call _Unwind_Resume
+- hlt
+-.LENDCODE:
+- cfi_endproc
+- .size __condvar_w_cleanup, .-__condvar_w_cleanup
+-
+-
+- .section .gcc_except_table,"a", at progbits
+-.LexceptSTART:
+- .byte DW_EH_PE_omit # @LPStart format (omit)
+- .byte DW_EH_PE_omit # @TType format (omit)
+- .byte DW_EH_PE_sdata4 # call-site format
+- # DW_EH_PE_sdata4
+- .uleb128 .Lcstend-.Lcstbegin
+-.Lcstbegin:
+- .long .LcleanupSTART-.LSTARTCODE
+- .long .Ladd_cond_futex_pi-.LcleanupSTART
+- .long __condvar_w_cleanup-.LSTARTCODE
+- .uleb128 0
+- .long .Ladd_cond_futex_pi-.LSTARTCODE
+- .long .Lsub_cond_futex_pi-.Ladd_cond_futex_pi
+- .long __condvar_w_cleanup2-.LSTARTCODE
+- .uleb128 0
+- .long .Lsub_cond_futex_pi-.LSTARTCODE
+- .long .Ladd_cond_futex-.Lsub_cond_futex_pi
+- .long __condvar_w_cleanup-.LSTARTCODE
+- .uleb128 0
+- .long .Ladd_cond_futex-.LSTARTCODE
+- .long .Lsub_cond_futex-.Ladd_cond_futex
+- .long __condvar_w_cleanup2-.LSTARTCODE
+- .uleb128 0
+- .long .Lsub_cond_futex-.LSTARTCODE
+- .long .LcleanupEND-.Lsub_cond_futex
+- .long __condvar_w_cleanup-.LSTARTCODE
+- .uleb128 0
+- .long .LcallUR-.LSTARTCODE
+- .long .LENDCODE-.LcallUR
+- .long 0
+- .uleb128 0
+-.Lcstend:
+-
+-#ifdef SHARED
+- .hidden DW.ref.__gcc_personality_v0
+- .weak DW.ref.__gcc_personality_v0
+- .section .gnu.linkonce.d.DW.ref.__gcc_personality_v0,"aw", at progbits
+- .align 4
+- .type DW.ref.__gcc_personality_v0, @object
+- .size DW.ref.__gcc_personality_v0, 4
+-DW.ref.__gcc_personality_v0:
+- .long __gcc_personality_v0
+-#endif
+diff --git a/sysdeps/unix/sysv/linux/powerpc/bits/pthreadtypes.h b/sysdeps/unix/sysv/linux/powerpc/bits/pthreadtypes.h
+index 345e79a..371bc3c 100644
+--- a/sysdeps/unix/sysv/linux/powerpc/bits/pthreadtypes.h
++++ b/sysdeps/unix/sysv/linux/powerpc/bits/pthreadtypes.h
+@@ -123,19 +123,32 @@ typedef union
+
+
+ /* Data structure for conditional variable handling. The structure of
+- the attribute type is deliberately not exposed. */
++ the attribute type is not exposed on purpose. */
+ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+diff --git a/sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S b/sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S
+deleted file mode 100644
+index de455dd..0000000
+--- a/sysdeps/unix/sysv/linux/x86_64/pthread_cond_broadcast.S
++++ /dev/null
+@@ -1,177 +0,0 @@
+-/* Copyright (C) 2002-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Ulrich Drepper <drepper at redhat.com>, 2002.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library; if not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#include <sysdep.h>
+-#include <shlib-compat.h>
+-#include <lowlevellock.h>
+-#include <lowlevelcond.h>
+-#include <kernel-features.h>
+-#include <pthread-pi-defines.h>
+-#include <pthread-errnos.h>
+-#include <stap-probe.h>
+-
+- .text
+-
+- /* int pthread_cond_broadcast (pthread_cond_t *cond) */
+-ENTRY(__pthread_cond_broadcast)
+-
+- LIBC_PROBE (cond_broadcast, 1, %rdi)
+-
+- /* Get internal lock. */
+- movl $1, %esi
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %esi, (%rdi)
+-#else
+- cmpxchgl %esi, cond_lock(%rdi)
+-#endif
+- jnz 1f
+-
+-2: addq $cond_futex, %rdi
+- movq total_seq-cond_futex(%rdi), %r9
+- cmpq wakeup_seq-cond_futex(%rdi), %r9
+- jna 4f
+-
+- /* Cause all currently waiting threads to recognize they are
+- woken up. */
+- movq %r9, wakeup_seq-cond_futex(%rdi)
+- movq %r9, woken_seq-cond_futex(%rdi)
+- addq %r9, %r9
+- movl %r9d, (%rdi)
+- incl broadcast_seq-cond_futex(%rdi)
+-
+- /* Get the address of the mutex used. */
+- mov dep_mutex-cond_futex(%rdi), %R8_LP
+-
+- /* Unlock. */
+- LOCK
+- decl cond_lock-cond_futex(%rdi)
+- jne 7f
+-
+-8: cmp $-1, %R8_LP
+- je 9f
+-
+- /* Do not use requeue for pshared condvars. */
+- testl $PS_BIT, MUTEX_KIND(%r8)
+- jne 9f
+-
+- /* Requeue to a PI mutex if the PI bit is set. */
+- movl MUTEX_KIND(%r8), %eax
+- andl $(ROBUST_BIT|PI_BIT), %eax
+- cmpl $PI_BIT, %eax
+- je 81f
+-
+- /* Wake up all threads. */
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $(FUTEX_CMP_REQUEUE|FUTEX_PRIVATE_FLAG), %esi
+-#else
+- movl %fs:PRIVATE_FUTEX, %esi
+- orl $FUTEX_CMP_REQUEUE, %esi
+-#endif
+- movl $SYS_futex, %eax
+- movl $1, %edx
+- movl $0x7fffffff, %r10d
+- syscall
+-
+- /* For any kind of error, which mainly is EAGAIN, we try again
+- with WAKE. The general test also covers running on old
+- kernels. */
+- cmpq $-4095, %rax
+- jae 9f
+-
+-10: xorl %eax, %eax
+- retq
+-
+- /* Wake up all threads. */
+-81: movl $(FUTEX_CMP_REQUEUE_PI|FUTEX_PRIVATE_FLAG), %esi
+- movl $SYS_futex, %eax
+- movl $1, %edx
+- movl $0x7fffffff, %r10d
+- syscall
+-
+- /* For any kind of error, which mainly is EAGAIN, we try again
+- with WAKE. The general test also covers running on old
+- kernels. */
+- cmpq $-4095, %rax
+- jb 10b
+- jmp 9f
+-
+- .align 16
+- /* Unlock. */
+-4: LOCK
+- decl cond_lock-cond_futex(%rdi)
+- jne 5f
+-
+-6: xorl %eax, %eax
+- retq
+-
+- /* Initial locking failed. */
+-1:
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_lock_wait
+-#if cond_lock != 0
+- subq $cond_lock, %rdi
+-#endif
+- jmp 2b
+-
+- /* Unlock in loop requires wakeup. */
+-5: addq $cond_lock-cond_futex, %rdi
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_unlock_wake
+- jmp 6b
+-
+- /* Unlock in loop requires wakeup. */
+-7: addq $cond_lock-cond_futex, %rdi
+- cmp $-1, %R8_LP
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_unlock_wake
+- subq $cond_lock-cond_futex, %rdi
+- jmp 8b
+-
+-9: /* The futex requeue functionality is not available. */
+- cmp $-1, %R8_LP
+- movl $0x7fffffff, %edx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $FUTEX_WAKE, %eax
+- movl $(FUTEX_WAKE|FUTEX_PRIVATE_FLAG), %esi
+- cmove %eax, %esi
+-#else
+- movl $0, %eax
+- movl %fs:PRIVATE_FUTEX, %esi
+- cmove %eax, %esi
+- orl $FUTEX_WAKE, %esi
+-#endif
+- movl $SYS_futex, %eax
+- syscall
+- jmp 10b
+-END(__pthread_cond_broadcast)
+-
+-versioned_symbol (libpthread, __pthread_cond_broadcast, pthread_cond_broadcast,
+- GLIBC_2_3_2)
+diff --git a/sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S b/sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S
+deleted file mode 100644
+index da14bc3..0000000
+--- a/sysdeps/unix/sysv/linux/x86_64/pthread_cond_signal.S
++++ /dev/null
+@@ -1,161 +0,0 @@
+-/* Copyright (C) 2002-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Ulrich Drepper <drepper at redhat.com>, 2002.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library; if not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#include <sysdep.h>
+-#include <shlib-compat.h>
+-#include <lowlevellock.h>
+-#include <lowlevelcond.h>
+-#include <pthread-pi-defines.h>
+-#include <kernel-features.h>
+-#include <pthread-errnos.h>
+-#include <stap-probe.h>
+-
+-
+- .text
+-
+-ENTRY(__pthread_cond_signal)
+-
+- LIBC_PROBE (cond_signal, 1, %rdi)
+-
+- /* Get internal lock. */
+- movq %rdi, %r8
+- movl $1, %esi
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %esi, (%rdi)
+-#else
+- cmpxchgl %esi, cond_lock(%rdi)
+-#endif
+- jnz 1f
+-
+-2: addq $cond_futex, %rdi
+- movq total_seq(%r8), %rcx
+- cmpq wakeup_seq(%r8), %rcx
+- jbe 4f
+-
+- /* Bump the wakeup number. */
+- addq $1, wakeup_seq(%r8)
+- addl $1, (%rdi)
+-
+- /* Wake up one thread. */
+- LP_OP(cmp) $-1, dep_mutex(%r8)
+- movl $FUTEX_WAKE_OP, %esi
+- movl $1, %edx
+- movl $SYS_futex, %eax
+- je 8f
+-
+- /* Get the address of the mutex used. */
+- mov dep_mutex(%r8), %RCX_LP
+- movl MUTEX_KIND(%rcx), %r11d
+- andl $(ROBUST_BIT|PI_BIT), %r11d
+- cmpl $PI_BIT, %r11d
+- je 9f
+-
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $(FUTEX_WAKE_OP|FUTEX_PRIVATE_FLAG), %esi
+-#else
+- orl %fs:PRIVATE_FUTEX, %esi
+-#endif
+-
+-8: movl $1, %r10d
+-#if cond_lock != 0
+- addq $cond_lock, %r8
+-#endif
+- movl $FUTEX_OP_CLEAR_WAKE_IF_GT_ONE, %r9d
+- syscall
+-#if cond_lock != 0
+- subq $cond_lock, %r8
+-#endif
+- /* For any kind of error, we try again with WAKE.
+- The general test also covers running on old kernels. */
+- cmpq $-4095, %rax
+- jae 7f
+-
+- xorl %eax, %eax
+- retq
+-
+- /* Wake up one thread and requeue none in the PI Mutex case. */
+-9: movl $(FUTEX_CMP_REQUEUE_PI|FUTEX_PRIVATE_FLAG), %esi
+- movq %rcx, %r8
+- xorq %r10, %r10
+- movl (%rdi), %r9d // XXX Can this be right?
+- syscall
+-
+- leaq -cond_futex(%rdi), %r8
+-
+- /* For any kind of error, we try again with WAKE.
+- The general test also covers running on old kernels. */
+- cmpq $-4095, %rax
+- jb 4f
+-
+-7:
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- andl $FUTEX_PRIVATE_FLAG, %esi
+-#else
+- andl %fs:PRIVATE_FUTEX, %esi
+-#endif
+- orl $FUTEX_WAKE, %esi
+- movl $SYS_futex, %eax
+- /* %rdx should be 1 already from $FUTEX_WAKE_OP syscall.
+- movl $1, %edx */
+- syscall
+-
+- /* Unlock. */
+-4: LOCK
+-#if cond_lock == 0
+- decl (%r8)
+-#else
+- decl cond_lock(%r8)
+-#endif
+- jne 5f
+-
+-6: xorl %eax, %eax
+- retq
+-
+- /* Initial locking failed. */
+-1:
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_lock_wait
+-#if cond_lock != 0
+- subq $cond_lock, %rdi
+-#endif
+- jmp 2b
+-
+- /* Unlock in loop requires wakeup. */
+-5:
+- movq %r8, %rdi
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_unlock_wake
+- jmp 6b
+-END(__pthread_cond_signal)
+-
+-versioned_symbol (libpthread, __pthread_cond_signal, pthread_cond_signal,
+- GLIBC_2_3_2)
+diff --git a/sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S b/sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S
+deleted file mode 100644
+index 82ffa1a..0000000
+--- a/sysdeps/unix/sysv/linux/x86_64/pthread_cond_timedwait.S
++++ /dev/null
+@@ -1,623 +0,0 @@
+-/* Copyright (C) 2002-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Ulrich Drepper <drepper at redhat.com>, 2002.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library; if not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#include <sysdep.h>
+-#include <shlib-compat.h>
+-#include <lowlevellock.h>
+-#include <lowlevelcond.h>
+-#include <pthread-pi-defines.h>
+-#include <pthread-errnos.h>
+-#include <stap-probe.h>
+-
+-#include <kernel-features.h>
+-
+-
+- .text
+-
+-
+-/* int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex,
+- const struct timespec *abstime) */
+- .globl __pthread_cond_timedwait
+- .type __pthread_cond_timedwait, @function
+- .align 16
+-__pthread_cond_timedwait:
+-.LSTARTCODE:
+- cfi_startproc
+-#ifdef SHARED
+- cfi_personality(DW_EH_PE_pcrel | DW_EH_PE_sdata4 | DW_EH_PE_indirect,
+- DW.ref.__gcc_personality_v0)
+- cfi_lsda(DW_EH_PE_pcrel | DW_EH_PE_sdata4, .LexceptSTART)
+-#else
+- cfi_personality(DW_EH_PE_udata4, __gcc_personality_v0)
+- cfi_lsda(DW_EH_PE_udata4, .LexceptSTART)
+-#endif
+-
+- pushq %r12
+- cfi_adjust_cfa_offset(8)
+- cfi_rel_offset(%r12, 0)
+- pushq %r13
+- cfi_adjust_cfa_offset(8)
+- cfi_rel_offset(%r13, 0)
+- pushq %r14
+- cfi_adjust_cfa_offset(8)
+- cfi_rel_offset(%r14, 0)
+- pushq %r15
+- cfi_adjust_cfa_offset(8)
+- cfi_rel_offset(%r15, 0)
+-#define FRAME_SIZE (32+8)
+- subq $FRAME_SIZE, %rsp
+- cfi_adjust_cfa_offset(FRAME_SIZE)
+- cfi_remember_state
+-
+- LIBC_PROBE (cond_timedwait, 3, %rdi, %rsi, %rdx)
+-
+- cmpq $1000000000, 8(%rdx)
+- movl $EINVAL, %eax
+- jae 48f
+-
+- /* Stack frame:
+-
+- rsp + 48
+- +--------------------------+
+- rsp + 32 | timeout value |
+- +--------------------------+
+- rsp + 24 | old wake_seq value |
+- +--------------------------+
+- rsp + 16 | mutex pointer |
+- +--------------------------+
+- rsp + 8 | condvar pointer |
+- +--------------------------+
+- rsp + 4 | old broadcast_seq value |
+- +--------------------------+
+- rsp + 0 | old cancellation mode |
+- +--------------------------+
+- */
+-
+- LP_OP(cmp) $-1, dep_mutex(%rdi)
+-
+- /* Prepare structure passed to cancellation handler. */
+- movq %rdi, 8(%rsp)
+- movq %rsi, 16(%rsp)
+- movq %rdx, %r13
+-
+- je 22f
+- mov %RSI_LP, dep_mutex(%rdi)
+-
+-22:
+- xorb %r15b, %r15b
+-
+- /* Get internal lock. */
+- movl $1, %esi
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %esi, (%rdi)
+-#else
+- cmpxchgl %esi, cond_lock(%rdi)
+-#endif
+- jnz 31f
+-
+- /* Unlock the mutex. */
+-32: movq 16(%rsp), %rdi
+- xorl %esi, %esi
+- callq __pthread_mutex_unlock_usercnt
+-
+- testl %eax, %eax
+- jne 46f
+-
+- movq 8(%rsp), %rdi
+- incq total_seq(%rdi)
+- incl cond_futex(%rdi)
+- addl $(1 << nwaiters_shift), cond_nwaiters(%rdi)
+-
+- /* Get and store current wakeup_seq value. */
+- movq 8(%rsp), %rdi
+- movq wakeup_seq(%rdi), %r9
+- movl broadcast_seq(%rdi), %edx
+- movq %r9, 24(%rsp)
+- movl %edx, 4(%rsp)
+-
+- cmpq $0, (%r13)
+- movq $-ETIMEDOUT, %r14
+- js 36f
+-
+-38: movl cond_futex(%rdi), %r12d
+-
+- /* Unlock. */
+- LOCK
+-#if cond_lock == 0
+- decl (%rdi)
+-#else
+- decl cond_lock(%rdi)
+-#endif
+- jne 33f
+-
+-.LcleanupSTART1:
+-34: callq __pthread_enable_asynccancel
+- movl %eax, (%rsp)
+-
+- movq %r13, %r10
+- movl $FUTEX_WAIT_BITSET, %esi
+- LP_OP(cmp) $-1, dep_mutex(%rdi)
+- je 60f
+-
+- mov dep_mutex(%rdi), %R8_LP
+- /* Requeue to a non-robust PI mutex if the PI bit is set and
+- the robust bit is not set. */
+- movl MUTEX_KIND(%r8), %eax
+- andl $(ROBUST_BIT|PI_BIT), %eax
+- cmpl $PI_BIT, %eax
+- jne 61f
+-
+- movl $(FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG), %esi
+- xorl %eax, %eax
+- /* The following only works like this because we only support
+- two clocks, represented using a single bit. */
+- testl $1, cond_nwaiters(%rdi)
+- movl $FUTEX_CLOCK_REALTIME, %edx
+- cmove %edx, %eax
+- orl %eax, %esi
+- movq %r12, %rdx
+- addq $cond_futex, %rdi
+- movl $SYS_futex, %eax
+- syscall
+-
+- cmpl $0, %eax
+- sete %r15b
+-
+-#ifdef __ASSUME_REQUEUE_PI
+- jmp 62f
+-#else
+- je 62f
+-
+- /* When a futex syscall with FUTEX_WAIT_REQUEUE_PI returns
+- successfully, it has already locked the mutex for us and the
+- pi_flag (%r15b) is set to denote that fact. However, if another
+- thread changed the futex value before we entered the wait, the
+- syscall may return an EAGAIN and the mutex is not locked. We go
+- ahead with a success anyway since later we look at the pi_flag to
+- decide if we got the mutex or not. The sequence numbers then make
+- sure that only one of the threads actually wake up. We retry using
+- normal FUTEX_WAIT only if the kernel returned ENOSYS, since normal
+- and PI futexes don't mix.
+-
+- Note that we don't check for EAGAIN specifically; we assume that the
+- only other error the futex function could return is EAGAIN (barring
+- the ETIMEOUT of course, for the timeout case in futex) since
+- anything else would mean an error in our function. It is too
+- expensive to do that check for every call (which is quite common in
+- case of a large number of threads), so it has been skipped. */
+- cmpl $-ENOSYS, %eax
+- jne 62f
+-
+- subq $cond_futex, %rdi
+-#endif
+-
+-61: movl $(FUTEX_WAIT_BITSET|FUTEX_PRIVATE_FLAG), %esi
+-60: xorb %r15b, %r15b
+- xorl %eax, %eax
+- /* The following only works like this because we only support
+- two clocks, represented using a single bit. */
+- testl $1, cond_nwaiters(%rdi)
+- movl $FUTEX_CLOCK_REALTIME, %edx
+- movl $0xffffffff, %r9d
+- cmove %edx, %eax
+- orl %eax, %esi
+- movq %r12, %rdx
+- addq $cond_futex, %rdi
+- movl $SYS_futex, %eax
+- syscall
+-62: movq %rax, %r14
+-
+- movl (%rsp), %edi
+- callq __pthread_disable_asynccancel
+-.LcleanupEND1:
+-
+- /* Lock. */
+- movq 8(%rsp), %rdi
+- movl $1, %esi
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %esi, (%rdi)
+-#else
+- cmpxchgl %esi, cond_lock(%rdi)
+-#endif
+- jne 35f
+-
+-36: movl broadcast_seq(%rdi), %edx
+-
+- movq woken_seq(%rdi), %rax
+-
+- movq wakeup_seq(%rdi), %r9
+-
+- cmpl 4(%rsp), %edx
+- jne 53f
+-
+- cmpq 24(%rsp), %r9
+- jbe 45f
+-
+- cmpq %rax, %r9
+- ja 39f
+-
+-45: cmpq $-ETIMEDOUT, %r14
+- je 99f
+-
+- /* We need to go back to futex_wait. If we're using requeue_pi, then
+- release the mutex we had acquired and go back. */
+- test %r15b, %r15b
+- jz 38b
+-
+- /* Adjust the mutex values first and then unlock it. The unlock
+- should always succeed or else the kernel did not lock the
+- mutex correctly. */
+- movq %r8, %rdi
+- callq __pthread_mutex_cond_lock_adjust
+- xorl %esi, %esi
+- callq __pthread_mutex_unlock_usercnt
+- /* Reload cond_var. */
+- movq 8(%rsp), %rdi
+- jmp 38b
+-
+-99: incq wakeup_seq(%rdi)
+- incl cond_futex(%rdi)
+- movl $ETIMEDOUT, %r14d
+- jmp 44f
+-
+-53: xorq %r14, %r14
+- jmp 54f
+-
+-39: xorq %r14, %r14
+-44: incq woken_seq(%rdi)
+-
+-54: subl $(1 << nwaiters_shift), cond_nwaiters(%rdi)
+-
+- /* Wake up a thread which wants to destroy the condvar object. */
+- cmpq $0xffffffffffffffff, total_seq(%rdi)
+- jne 55f
+- movl cond_nwaiters(%rdi), %eax
+- andl $~((1 << nwaiters_shift) - 1), %eax
+- jne 55f
+-
+- addq $cond_nwaiters, %rdi
+- LP_OP(cmp) $-1, dep_mutex-cond_nwaiters(%rdi)
+- movl $1, %edx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $FUTEX_WAKE, %eax
+- movl $(FUTEX_WAKE|FUTEX_PRIVATE_FLAG), %esi
+- cmove %eax, %esi
+-#else
+- movl $0, %eax
+- movl %fs:PRIVATE_FUTEX, %esi
+- cmove %eax, %esi
+- orl $FUTEX_WAKE, %esi
+-#endif
+- movl $SYS_futex, %eax
+- syscall
+- subq $cond_nwaiters, %rdi
+-
+-55: LOCK
+-#if cond_lock == 0
+- decl (%rdi)
+-#else
+- decl cond_lock(%rdi)
+-#endif
+- jne 40f
+-
+- /* If requeue_pi is used the kernel performs the locking of the
+- mutex. */
+-41: movq 16(%rsp), %rdi
+- testb %r15b, %r15b
+- jnz 64f
+-
+- callq __pthread_mutex_cond_lock
+-
+-63: testq %rax, %rax
+- cmoveq %r14, %rax
+-
+-48: addq $FRAME_SIZE, %rsp
+- cfi_adjust_cfa_offset(-FRAME_SIZE)
+- popq %r15
+- cfi_adjust_cfa_offset(-8)
+- cfi_restore(%r15)
+- popq %r14
+- cfi_adjust_cfa_offset(-8)
+- cfi_restore(%r14)
+- popq %r13
+- cfi_adjust_cfa_offset(-8)
+- cfi_restore(%r13)
+- popq %r12
+- cfi_adjust_cfa_offset(-8)
+- cfi_restore(%r12)
+-
+- retq
+-
+- cfi_restore_state
+-
+-64: callq __pthread_mutex_cond_lock_adjust
+- movq %r14, %rax
+- jmp 48b
+-
+- /* Initial locking failed. */
+-31:
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_lock_wait
+- jmp 32b
+-
+- /* Unlock in loop requires wakeup. */
+-33:
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_unlock_wake
+- jmp 34b
+-
+- /* Locking in loop failed. */
+-35:
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_lock_wait
+-#if cond_lock != 0
+- subq $cond_lock, %rdi
+-#endif
+- jmp 36b
+-
+- /* Unlock after loop requires wakeup. */
+-40:
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_unlock_wake
+- jmp 41b
+-
+- /* The initial unlocking of the mutex failed. */
+-46: movq 8(%rsp), %rdi
+- movq %rax, (%rsp)
+- LOCK
+-#if cond_lock == 0
+- decl (%rdi)
+-#else
+- decl cond_lock(%rdi)
+-#endif
+- jne 47f
+-
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_unlock_wake
+-
+-47: movq (%rsp), %rax
+- jmp 48b
+-
+- .size __pthread_cond_timedwait, .-__pthread_cond_timedwait
+-versioned_symbol (libpthread, __pthread_cond_timedwait, pthread_cond_timedwait,
+- GLIBC_2_3_2)
+-
+-
+- .align 16
+- .type __condvar_cleanup2, @function
+-__condvar_cleanup2:
+- /* Stack frame:
+-
+- rsp + 72
+- +--------------------------+
+- rsp + 64 | %r12 |
+- +--------------------------+
+- rsp + 56 | %r13 |
+- +--------------------------+
+- rsp + 48 | %r14 |
+- +--------------------------+
+- rsp + 24 | unused |
+- +--------------------------+
+- rsp + 16 | mutex pointer |
+- +--------------------------+
+- rsp + 8 | condvar pointer |
+- +--------------------------+
+- rsp + 4 | old broadcast_seq value |
+- +--------------------------+
+- rsp + 0 | old cancellation mode |
+- +--------------------------+
+- */
+-
+- movq %rax, 24(%rsp)
+-
+- /* Get internal lock. */
+- movq 8(%rsp), %rdi
+- movl $1, %esi
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %esi, (%rdi)
+-#else
+- cmpxchgl %esi, cond_lock(%rdi)
+-#endif
+- jz 1f
+-
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_lock_wait
+-#if cond_lock != 0
+- subq $cond_lock, %rdi
+-#endif
+-
+-1: movl broadcast_seq(%rdi), %edx
+- cmpl 4(%rsp), %edx
+- jne 3f
+-
+- /* We increment the wakeup_seq counter only if it is lower than
+- total_seq. If this is not the case the thread was woken and
+- then canceled. In this case we ignore the signal. */
+- movq total_seq(%rdi), %rax
+- cmpq wakeup_seq(%rdi), %rax
+- jbe 6f
+- incq wakeup_seq(%rdi)
+- incl cond_futex(%rdi)
+-6: incq woken_seq(%rdi)
+-
+-3: subl $(1 << nwaiters_shift), cond_nwaiters(%rdi)
+-
+- /* Wake up a thread which wants to destroy the condvar object. */
+- xorq %r12, %r12
+- cmpq $0xffffffffffffffff, total_seq(%rdi)
+- jne 4f
+- movl cond_nwaiters(%rdi), %eax
+- andl $~((1 << nwaiters_shift) - 1), %eax
+- jne 4f
+-
+- LP_OP(cmp) $-1, dep_mutex(%rdi)
+- leaq cond_nwaiters(%rdi), %rdi
+- movl $1, %edx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $FUTEX_WAKE, %eax
+- movl $(FUTEX_WAKE|FUTEX_PRIVATE_FLAG), %esi
+- cmove %eax, %esi
+-#else
+- movl $0, %eax
+- movl %fs:PRIVATE_FUTEX, %esi
+- cmove %eax, %esi
+- orl $FUTEX_WAKE, %esi
+-#endif
+- movl $SYS_futex, %eax
+- syscall
+- subq $cond_nwaiters, %rdi
+- movl $1, %r12d
+-
+-4: LOCK
+-#if cond_lock == 0
+- decl (%rdi)
+-#else
+- decl cond_lock(%rdi)
+-#endif
+- je 2f
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_unlock_wake
+-
+- /* Wake up all waiters to make sure no signal gets lost. */
+-2: testq %r12, %r12
+- jnz 5f
+- addq $cond_futex, %rdi
+- LP_OP(cmp) $-1, dep_mutex-cond_futex(%rdi)
+- movl $0x7fffffff, %edx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $FUTEX_WAKE, %eax
+- movl $(FUTEX_WAKE|FUTEX_PRIVATE_FLAG), %esi
+- cmove %eax, %esi
+-#else
+- movl $0, %eax
+- movl %fs:PRIVATE_FUTEX, %esi
+- cmove %eax, %esi
+- orl $FUTEX_WAKE, %esi
+-#endif
+- movl $SYS_futex, %eax
+- syscall
+-
+- /* Lock the mutex only if we don't own it already. This only happens
+- in case of PI mutexes, if we got cancelled after a successful
+- return of the futex syscall and before disabling async
+- cancellation. */
+-5: movq 16(%rsp), %rdi
+- movl MUTEX_KIND(%rdi), %eax
+- andl $(ROBUST_BIT|PI_BIT), %eax
+- cmpl $PI_BIT, %eax
+- jne 7f
+-
+- movl (%rdi), %eax
+- andl $TID_MASK, %eax
+- cmpl %eax, %fs:TID
+- jne 7f
+- /* We managed to get the lock. Fix it up before returning. */
+- callq __pthread_mutex_cond_lock_adjust
+- jmp 8f
+-
+-7: callq __pthread_mutex_cond_lock
+-
+-8: movq 24(%rsp), %rdi
+- movq FRAME_SIZE(%rsp), %r15
+- movq FRAME_SIZE+8(%rsp), %r14
+- movq FRAME_SIZE+16(%rsp), %r13
+- movq FRAME_SIZE+24(%rsp), %r12
+-.LcallUR:
+- call _Unwind_Resume
+- hlt
+-.LENDCODE:
+- cfi_endproc
+- .size __condvar_cleanup2, .-__condvar_cleanup2
+-
+-
+- .section .gcc_except_table,"a", at progbits
+-.LexceptSTART:
+- .byte DW_EH_PE_omit # @LPStart format
+- .byte DW_EH_PE_omit # @TType format
+- .byte DW_EH_PE_uleb128 # call-site format
+- .uleb128 .Lcstend-.Lcstbegin
+-.Lcstbegin:
+- .uleb128 .LcleanupSTART1-.LSTARTCODE
+- .uleb128 .LcleanupEND1-.LcleanupSTART1
+- .uleb128 __condvar_cleanup2-.LSTARTCODE
+- .uleb128 0
+- .uleb128 .LcallUR-.LSTARTCODE
+- .uleb128 .LENDCODE-.LcallUR
+- .uleb128 0
+- .uleb128 0
+-.Lcstend:
+-
+-
+-#ifdef SHARED
+- .hidden DW.ref.__gcc_personality_v0
+- .weak DW.ref.__gcc_personality_v0
+- .section .gnu.linkonce.d.DW.ref.__gcc_personality_v0,"aw", at progbits
+- .align LP_SIZE
+- .type DW.ref.__gcc_personality_v0, @object
+- .size DW.ref.__gcc_personality_v0, LP_SIZE
+-DW.ref.__gcc_personality_v0:
+- ASM_ADDR __gcc_personality_v0
+-#endif
+diff --git a/sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S b/sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S
+deleted file mode 100644
+index c82f37b..0000000
+--- a/sysdeps/unix/sysv/linux/x86_64/pthread_cond_wait.S
++++ /dev/null
+@@ -1,555 +0,0 @@
+-/* Copyright (C) 2002-2016 Free Software Foundation, Inc.
+- This file is part of the GNU C Library.
+- Contributed by Ulrich Drepper <drepper at redhat.com>, 2002.
+-
+- The GNU C Library is free software; you can redistribute it and/or
+- modify it under the terms of the GNU Lesser General Public
+- License as published by the Free Software Foundation; either
+- version 2.1 of the License, or (at your option) any later version.
+-
+- The GNU C Library is distributed in the hope that it will be useful,
+- but WITHOUT ANY WARRANTY; without even the implied warranty of
+- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+- Lesser General Public License for more details.
+-
+- You should have received a copy of the GNU Lesser General Public
+- License along with the GNU C Library; if not, see
+- <http://www.gnu.org/licenses/>. */
+-
+-#include <sysdep.h>
+-#include <shlib-compat.h>
+-#include <lowlevellock.h>
+-#include <lowlevelcond.h>
+-#include <tcb-offsets.h>
+-#include <pthread-pi-defines.h>
+-#include <pthread-errnos.h>
+-#include <stap-probe.h>
+-
+-#include <kernel-features.h>
+-
+-
+- .text
+-
+-/* int pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex) */
+- .globl __pthread_cond_wait
+- .type __pthread_cond_wait, @function
+- .align 16
+-__pthread_cond_wait:
+-.LSTARTCODE:
+- cfi_startproc
+-#ifdef SHARED
+- cfi_personality(DW_EH_PE_pcrel | DW_EH_PE_sdata4 | DW_EH_PE_indirect,
+- DW.ref.__gcc_personality_v0)
+- cfi_lsda(DW_EH_PE_pcrel | DW_EH_PE_sdata4, .LexceptSTART)
+-#else
+- cfi_personality(DW_EH_PE_udata4, __gcc_personality_v0)
+- cfi_lsda(DW_EH_PE_udata4, .LexceptSTART)
+-#endif
+-
+-#define FRAME_SIZE (32+8)
+- leaq -FRAME_SIZE(%rsp), %rsp
+- cfi_adjust_cfa_offset(FRAME_SIZE)
+-
+- /* Stack frame:
+-
+- rsp + 32
+- +--------------------------+
+- rsp + 24 | old wake_seq value |
+- +--------------------------+
+- rsp + 16 | mutex pointer |
+- +--------------------------+
+- rsp + 8 | condvar pointer |
+- +--------------------------+
+- rsp + 4 | old broadcast_seq value |
+- +--------------------------+
+- rsp + 0 | old cancellation mode |
+- +--------------------------+
+- */
+-
+- LIBC_PROBE (cond_wait, 2, %rdi, %rsi)
+-
+- LP_OP(cmp) $-1, dep_mutex(%rdi)
+-
+- /* Prepare structure passed to cancellation handler. */
+- movq %rdi, 8(%rsp)
+- movq %rsi, 16(%rsp)
+-
+- je 15f
+- mov %RSI_LP, dep_mutex(%rdi)
+-
+- /* Get internal lock. */
+-15: movl $1, %esi
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %esi, (%rdi)
+-#else
+- cmpxchgl %esi, cond_lock(%rdi)
+-#endif
+- jne 1f
+-
+- /* Unlock the mutex. */
+-2: movq 16(%rsp), %rdi
+- xorl %esi, %esi
+- callq __pthread_mutex_unlock_usercnt
+-
+- testl %eax, %eax
+- jne 12f
+-
+- movq 8(%rsp), %rdi
+- incq total_seq(%rdi)
+- incl cond_futex(%rdi)
+- addl $(1 << nwaiters_shift), cond_nwaiters(%rdi)
+-
+- /* Get and store current wakeup_seq value. */
+- movq 8(%rsp), %rdi
+- movq wakeup_seq(%rdi), %r9
+- movl broadcast_seq(%rdi), %edx
+- movq %r9, 24(%rsp)
+- movl %edx, 4(%rsp)
+-
+- /* Unlock. */
+-8: movl cond_futex(%rdi), %edx
+- LOCK
+-#if cond_lock == 0
+- decl (%rdi)
+-#else
+- decl cond_lock(%rdi)
+-#endif
+- jne 3f
+-
+-.LcleanupSTART:
+-4: callq __pthread_enable_asynccancel
+- movl %eax, (%rsp)
+-
+- xorq %r10, %r10
+- LP_OP(cmp) $-1, dep_mutex(%rdi)
+- leaq cond_futex(%rdi), %rdi
+- movl $FUTEX_WAIT, %esi
+- je 60f
+-
+- mov dep_mutex-cond_futex(%rdi), %R8_LP
+- /* Requeue to a non-robust PI mutex if the PI bit is set and
+- the robust bit is not set. */
+- movl MUTEX_KIND(%r8), %eax
+- andl $(ROBUST_BIT|PI_BIT), %eax
+- cmpl $PI_BIT, %eax
+- jne 61f
+-
+- movl $(FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG), %esi
+- movl $SYS_futex, %eax
+- syscall
+-
+- cmpl $0, %eax
+- sete %r8b
+-
+-#ifdef __ASSUME_REQUEUE_PI
+- jmp 62f
+-#else
+- je 62f
+-
+- /* When a futex syscall with FUTEX_WAIT_REQUEUE_PI returns
+- successfully, it has already locked the mutex for us and the
+- pi_flag (%r8b) is set to denote that fact. However, if another
+- thread changed the futex value before we entered the wait, the
+- syscall may return an EAGAIN and the mutex is not locked. We go
+- ahead with a success anyway since later we look at the pi_flag to
+- decide if we got the mutex or not. The sequence numbers then make
+- sure that only one of the threads actually wake up. We retry using
+- normal FUTEX_WAIT only if the kernel returned ENOSYS, since normal
+- and PI futexes don't mix.
+-
+- Note that we don't check for EAGAIN specifically; we assume that the
+- only other error the futex function could return is EAGAIN since
+- anything else would mean an error in our function. It is too
+- expensive to do that check for every call (which is quite common in
+- case of a large number of threads), so it has been skipped. */
+- cmpl $-ENOSYS, %eax
+- jne 62f
+-
+-# ifndef __ASSUME_PRIVATE_FUTEX
+- movl $FUTEX_WAIT, %esi
+-# endif
+-#endif
+-
+-61:
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $(FUTEX_WAIT|FUTEX_PRIVATE_FLAG), %esi
+-#else
+- orl %fs:PRIVATE_FUTEX, %esi
+-#endif
+-60: xorb %r8b, %r8b
+- movl $SYS_futex, %eax
+- syscall
+-
+-62: movl (%rsp), %edi
+- callq __pthread_disable_asynccancel
+-.LcleanupEND:
+-
+- /* Lock. */
+- movq 8(%rsp), %rdi
+- movl $1, %esi
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %esi, (%rdi)
+-#else
+- cmpxchgl %esi, cond_lock(%rdi)
+-#endif
+- jnz 5f
+-
+-6: movl broadcast_seq(%rdi), %edx
+-
+- movq woken_seq(%rdi), %rax
+-
+- movq wakeup_seq(%rdi), %r9
+-
+- cmpl 4(%rsp), %edx
+- jne 16f
+-
+- cmpq 24(%rsp), %r9
+- jbe 19f
+-
+- cmpq %rax, %r9
+- jna 19f
+-
+- incq woken_seq(%rdi)
+-
+- /* Unlock */
+-16: subl $(1 << nwaiters_shift), cond_nwaiters(%rdi)
+-
+- /* Wake up a thread which wants to destroy the condvar object. */
+- cmpq $0xffffffffffffffff, total_seq(%rdi)
+- jne 17f
+- movl cond_nwaiters(%rdi), %eax
+- andl $~((1 << nwaiters_shift) - 1), %eax
+- jne 17f
+-
+- addq $cond_nwaiters, %rdi
+- LP_OP(cmp) $-1, dep_mutex-cond_nwaiters(%rdi)
+- movl $1, %edx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $FUTEX_WAKE, %eax
+- movl $(FUTEX_WAKE|FUTEX_PRIVATE_FLAG), %esi
+- cmove %eax, %esi
+-#else
+- movl $0, %eax
+- movl %fs:PRIVATE_FUTEX, %esi
+- cmove %eax, %esi
+- orl $FUTEX_WAKE, %esi
+-#endif
+- movl $SYS_futex, %eax
+- syscall
+- subq $cond_nwaiters, %rdi
+-
+-17: LOCK
+-#if cond_lock == 0
+- decl (%rdi)
+-#else
+- decl cond_lock(%rdi)
+-#endif
+- jne 10f
+-
+- /* If requeue_pi is used the kernel performs the locking of the
+- mutex. */
+-11: movq 16(%rsp), %rdi
+- testb %r8b, %r8b
+- jnz 18f
+-
+- callq __pthread_mutex_cond_lock
+-
+-14: leaq FRAME_SIZE(%rsp), %rsp
+- cfi_adjust_cfa_offset(-FRAME_SIZE)
+-
+- /* We return the result of the mutex_lock operation. */
+- retq
+-
+- cfi_adjust_cfa_offset(FRAME_SIZE)
+-
+-18: callq __pthread_mutex_cond_lock_adjust
+- xorl %eax, %eax
+- jmp 14b
+-
+- /* We need to go back to futex_wait. If we're using requeue_pi, then
+- release the mutex we had acquired and go back. */
+-19: testb %r8b, %r8b
+- jz 8b
+-
+- /* Adjust the mutex values first and then unlock it. The unlock
+- should always succeed or else the kernel did not lock the mutex
+- correctly. */
+- movq 16(%rsp), %rdi
+- callq __pthread_mutex_cond_lock_adjust
+- movq %rdi, %r8
+- xorl %esi, %esi
+- callq __pthread_mutex_unlock_usercnt
+- /* Reload cond_var. */
+- movq 8(%rsp), %rdi
+- jmp 8b
+-
+- /* Initial locking failed. */
+-1:
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_lock_wait
+- jmp 2b
+-
+- /* Unlock in loop requires wakeup. */
+-3:
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- /* The call preserves %rdx. */
+- callq __lll_unlock_wake
+-#if cond_lock != 0
+- subq $cond_lock, %rdi
+-#endif
+- jmp 4b
+-
+- /* Locking in loop failed. */
+-5:
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_lock_wait
+-#if cond_lock != 0
+- subq $cond_lock, %rdi
+-#endif
+- jmp 6b
+-
+- /* Unlock after loop requires wakeup. */
+-10:
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_unlock_wake
+- jmp 11b
+-
+- /* The initial unlocking of the mutex failed. */
+-12: movq %rax, %r10
+- movq 8(%rsp), %rdi
+- LOCK
+-#if cond_lock == 0
+- decl (%rdi)
+-#else
+- decl cond_lock(%rdi)
+-#endif
+- je 13f
+-
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_unlock_wake
+-
+-13: movq %r10, %rax
+- jmp 14b
+-
+- .size __pthread_cond_wait, .-__pthread_cond_wait
+-versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait,
+- GLIBC_2_3_2)
+-
+-
+- .align 16
+- .type __condvar_cleanup1, @function
+- .globl __condvar_cleanup1
+- .hidden __condvar_cleanup1
+-__condvar_cleanup1:
+- /* Stack frame:
+-
+- rsp + 32
+- +--------------------------+
+- rsp + 24 | unused |
+- +--------------------------+
+- rsp + 16 | mutex pointer |
+- +--------------------------+
+- rsp + 8 | condvar pointer |
+- +--------------------------+
+- rsp + 4 | old broadcast_seq value |
+- +--------------------------+
+- rsp + 0 | old cancellation mode |
+- +--------------------------+
+- */
+-
+- movq %rax, 24(%rsp)
+-
+- /* Get internal lock. */
+- movq 8(%rsp), %rdi
+- movl $1, %esi
+- xorl %eax, %eax
+- LOCK
+-#if cond_lock == 0
+- cmpxchgl %esi, (%rdi)
+-#else
+- cmpxchgl %esi, cond_lock(%rdi)
+-#endif
+- jz 1f
+-
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- callq __lll_lock_wait
+-#if cond_lock != 0
+- subq $cond_lock, %rdi
+-#endif
+-
+-1: movl broadcast_seq(%rdi), %edx
+- cmpl 4(%rsp), %edx
+- jne 3f
+-
+- /* We increment the wakeup_seq counter only if it is lower than
+- total_seq. If this is not the case the thread was woken and
+- then canceled. In this case we ignore the signal. */
+- movq total_seq(%rdi), %rax
+- cmpq wakeup_seq(%rdi), %rax
+- jbe 6f
+- incq wakeup_seq(%rdi)
+- incl cond_futex(%rdi)
+-6: incq woken_seq(%rdi)
+-
+-3: subl $(1 << nwaiters_shift), cond_nwaiters(%rdi)
+-
+- /* Wake up a thread which wants to destroy the condvar object. */
+- xorl %ecx, %ecx
+- cmpq $0xffffffffffffffff, total_seq(%rdi)
+- jne 4f
+- movl cond_nwaiters(%rdi), %eax
+- andl $~((1 << nwaiters_shift) - 1), %eax
+- jne 4f
+-
+- LP_OP(cmp) $-1, dep_mutex(%rdi)
+- leaq cond_nwaiters(%rdi), %rdi
+- movl $1, %edx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $FUTEX_WAKE, %eax
+- movl $(FUTEX_WAKE|FUTEX_PRIVATE_FLAG), %esi
+- cmove %eax, %esi
+-#else
+- movl $0, %eax
+- movl %fs:PRIVATE_FUTEX, %esi
+- cmove %eax, %esi
+- orl $FUTEX_WAKE, %esi
+-#endif
+- movl $SYS_futex, %eax
+- syscall
+- subq $cond_nwaiters, %rdi
+- movl $1, %ecx
+-
+-4: LOCK
+-#if cond_lock == 0
+- decl (%rdi)
+-#else
+- decl cond_lock(%rdi)
+-#endif
+- je 2f
+-#if cond_lock != 0
+- addq $cond_lock, %rdi
+-#endif
+- LP_OP(cmp) $-1, dep_mutex-cond_lock(%rdi)
+- movl $LLL_PRIVATE, %eax
+- movl $LLL_SHARED, %esi
+- cmovne %eax, %esi
+- /* The call preserves %rcx. */
+- callq __lll_unlock_wake
+-
+- /* Wake up all waiters to make sure no signal gets lost. */
+-2: testl %ecx, %ecx
+- jnz 5f
+- addq $cond_futex, %rdi
+- LP_OP(cmp) $-1, dep_mutex-cond_futex(%rdi)
+- movl $0x7fffffff, %edx
+-#ifdef __ASSUME_PRIVATE_FUTEX
+- movl $FUTEX_WAKE, %eax
+- movl $(FUTEX_WAKE|FUTEX_PRIVATE_FLAG), %esi
+- cmove %eax, %esi
+-#else
+- movl $0, %eax
+- movl %fs:PRIVATE_FUTEX, %esi
+- cmove %eax, %esi
+- orl $FUTEX_WAKE, %esi
+-#endif
+- movl $SYS_futex, %eax
+- syscall
+-
+- /* Lock the mutex only if we don't own it already. This only happens
+- in case of PI mutexes, if we got cancelled after a successful
+- return of the futex syscall and before disabling async
+- cancellation. */
+-5: movq 16(%rsp), %rdi
+- movl MUTEX_KIND(%rdi), %eax
+- andl $(ROBUST_BIT|PI_BIT), %eax
+- cmpl $PI_BIT, %eax
+- jne 7f
+-
+- movl (%rdi), %eax
+- andl $TID_MASK, %eax
+- cmpl %eax, %fs:TID
+- jne 7f
+- /* We managed to get the lock. Fix it up before returning. */
+- callq __pthread_mutex_cond_lock_adjust
+- jmp 8f
+-
+-
+-7: callq __pthread_mutex_cond_lock
+-
+-8: movq 24(%rsp), %rdi
+-.LcallUR:
+- call _Unwind_Resume
+- hlt
+-.LENDCODE:
+- cfi_endproc
+- .size __condvar_cleanup1, .-__condvar_cleanup1
+-
+-
+- .section .gcc_except_table,"a", at progbits
+-.LexceptSTART:
+- .byte DW_EH_PE_omit # @LPStart format
+- .byte DW_EH_PE_omit # @TType format
+- .byte DW_EH_PE_uleb128 # call-site format
+- .uleb128 .Lcstend-.Lcstbegin
+-.Lcstbegin:
+- .uleb128 .LcleanupSTART-.LSTARTCODE
+- .uleb128 .LcleanupEND-.LcleanupSTART
+- .uleb128 __condvar_cleanup1-.LSTARTCODE
+- .uleb128 0
+- .uleb128 .LcallUR-.LSTARTCODE
+- .uleb128 .LENDCODE-.LcallUR
+- .uleb128 0
+- .uleb128 0
+-.Lcstend:
+-
+-
+-#ifdef SHARED
+- .hidden DW.ref.__gcc_personality_v0
+- .weak DW.ref.__gcc_personality_v0
+- .section .gnu.linkonce.d.DW.ref.__gcc_personality_v0,"aw", at progbits
+- .align LP_SIZE
+- .type DW.ref.__gcc_personality_v0, @object
+- .size DW.ref.__gcc_personality_v0, LP_SIZE
+-DW.ref.__gcc_personality_v0:
+- ASM_ADDR __gcc_personality_v0
+-#endif
+diff --git a/sysdeps/x86/bits/pthreadtypes.h b/sysdeps/x86/bits/pthreadtypes.h
+index 16b8f4f..a3a738f 100644
+--- a/sysdeps/x86/bits/pthreadtypes.h
++++ b/sysdeps/x86/bits/pthreadtypes.h
+@@ -140,14 +140,27 @@ typedef union
+ {
+ struct
+ {
+- int __lock;
+- unsigned int __futex;
+- __extension__ unsigned long long int __total_seq;
+- __extension__ unsigned long long int __wakeup_seq;
+- __extension__ unsigned long long int __woken_seq;
+- void *__mutex;
+- unsigned int __nwaiters;
+- unsigned int __broadcast_seq;
++ __extension__ union
++ {
++ __extension__ unsigned long long int __wseq;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __wseq32;
++ };
++ __extension__ union
++ {
++ __extension__ unsigned long long int __g1_start;
++ struct {
++ unsigned int __low;
++ unsigned int __high;
++ } __g1_start32;
++ };
++ unsigned int __g_refs[2];
++ unsigned int __g_size[2];
++ unsigned int __g1_orig_size;
++ unsigned int __wrefs;
++ unsigned int __g_signals[2];
+ } __data;
+ char __size[__SIZEOF_PTHREAD_COND_T];
+ __extension__ long long int __align;
+--
+2.10.2
+
diff --git a/meta/recipes-core/glibc/glibc/0005-Remove-__ASSUME_REQUEUE_PI.patch b/meta/recipes-core/glibc/glibc/0005-Remove-__ASSUME_REQUEUE_PI.patch
new file mode 100644
index 0000000..8d4ba41
--- /dev/null
+++ b/meta/recipes-core/glibc/glibc/0005-Remove-__ASSUME_REQUEUE_PI.patch
@@ -0,0 +1,149 @@
+From 27b7131d3d8133bf3a5ce72d4e4ff4dfadd71f20 Mon Sep 17 00:00:00 2001
+From: Catalin Enache <catalin.enache at windriver.com>
+Date: Fri, 30 Jun 2017 12:08:29 +0300
+Subject: [PATCH 5/6] Remove __ASSUME_REQUEUE_PI
+
+The new cond var implementation (ed19993b5b0d) removed all the
+__ASSUME_{REQUEUE_PI,FUTEX_LOCK_PI} internal usage so there is no
+need to keep defining it. This patch removes all USE_REQUEUE_PI
+and __ASSUME_REQUEUE_PI. It is as follow up from BZ#18463.
+
+Checked with a build for x86_64-linux-gnu, arm-linux-gnueabhf,
+m68-linux-gnu, mips64-linux-gnu, and sparc64-linux-gnu.
+
+ * nptl/pthreadP.h (USE_REQUEUE_PI): Remove ununsed macro.
+ * sysdeps/unix/sysv/linux/arm/kernel-features.h
+ (__ASSUME_REQUEUE_PI): Likewise.
+ * sysdeps/unix/sysv/linux/kernel-features.h
+ (__ASSUME_REQUEUE_PI): Likewise.
+ * sysdeps/unix/sysv/linux/m68k/kernel-features.h
+ (__ASSUME_REQUEUE_PI): Likewise.
+ * sysdeps/unix/sysv/linux/mips/kernel-features.h
+ (__ASSUME_REQUEUE_PI): Likewise.
+ * sysdeps/unix/sysv/linux/sparc/kernel-features.h
+ (__ASSUME_REQUEUE_PI): Likewise.
+
+Upstream-Status: Backport
+
+Author: Adhemerval Zanella <adhemerval.zanella at linaro.org>
+Signed-off-by: Catalin Enache <catalin.enache at windriver.com>
+---
+ ChangeLog | 14 ++++++++++++++
+ nptl/pthreadP.h | 12 ------------
+ sysdeps/unix/sysv/linux/arm/kernel-features.h | 1 -
+ sysdeps/unix/sysv/linux/kernel-features.h | 5 -----
+ sysdeps/unix/sysv/linux/m68k/kernel-features.h | 1 -
+ sysdeps/unix/sysv/linux/mips/kernel-features.h | 1 -
+ sysdeps/unix/sysv/linux/sparc/kernel-features.h | 1 -
+ 7 files changed, 14 insertions(+), 21 deletions(-)
+
+diff --git a/ChangeLog b/ChangeLog
+index c94db7b..44c518b 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,17 @@
++2017-04-04 Adhemerval Zanella <adhemerval.zanella at linaro.org>
++
++ * nptl/pthreadP.h (USE_REQUEUE_PI): Remove ununsed macro.
++ * sysdeps/unix/sysv/linux/arm/kernel-features.h
++ (__ASSUME_REQUEUE_PI): Likewise.
++ * sysdeps/unix/sysv/linux/kernel-features.h
++ (__ASSUME_REQUEUE_PI): Likewise.
++ * sysdeps/unix/sysv/linux/m68k/kernel-features.h
++ (__ASSUME_REQUEUE_PI): Likewise.
++ * sysdeps/unix/sysv/linux/mips/kernel-features.h
++ (__ASSUME_REQUEUE_PI): Likewise.
++ * sysdeps/unix/sysv/linux/sparc/kernel-features.h
++ (__ASSUME_REQUEUE_PI): Likewise.
++
+ 2016-12-31 Torvald Riegel <triegel at redhat.com>
+
+ [BZ #13165]
+diff --git a/nptl/pthreadP.h b/nptl/pthreadP.h
+index e9992bc..730c4ad 100644
+--- a/nptl/pthreadP.h
++++ b/nptl/pthreadP.h
+@@ -594,18 +594,6 @@ extern void __wait_lookup_done (void) attribute_hidden;
+ # define PTHREAD_STATIC_FN_REQUIRE(name) __asm (".globl " #name);
+ #endif
+
+-/* Test if the mutex is suitable for the FUTEX_WAIT_REQUEUE_PI operation. */
+-#if (defined lll_futex_wait_requeue_pi \
+- && defined __ASSUME_REQUEUE_PI)
+-# define USE_REQUEUE_PI(mut) \
+- ((mut) && (mut) != (void *) ~0l \
+- && (((mut)->__data.__kind \
+- & (PTHREAD_MUTEX_PRIO_INHERIT_NP | PTHREAD_MUTEX_ROBUST_NORMAL_NP)) \
+- == PTHREAD_MUTEX_PRIO_INHERIT_NP))
+-#else
+-# define USE_REQUEUE_PI(mut) 0
+-#endif
+-
+ /* Returns 0 if POL is a valid scheduling policy. */
+ static inline int
+ check_sched_policy_attr (int pol)
+diff --git a/sysdeps/unix/sysv/linux/arm/kernel-features.h b/sysdeps/unix/sysv/linux/arm/kernel-features.h
+index 6ca607e..339ad45 100644
+--- a/sysdeps/unix/sysv/linux/arm/kernel-features.h
++++ b/sysdeps/unix/sysv/linux/arm/kernel-features.h
+@@ -23,7 +23,6 @@
+ futex_atomic_cmpxchg_inatomic, depending on kernel
+ configuration. */
+ #if __LINUX_KERNEL_VERSION < 0x030E03
+-# undef __ASSUME_REQUEUE_PI
+ # undef __ASSUME_SET_ROBUST_LIST
+ #endif
+
+diff --git a/sysdeps/unix/sysv/linux/kernel-features.h b/sysdeps/unix/sysv/linux/kernel-features.h
+index 1d3b554..9f2cf9f 100644
+--- a/sysdeps/unix/sysv/linux/kernel-features.h
++++ b/sysdeps/unix/sysv/linux/kernel-features.h
+@@ -101,11 +101,6 @@
+ #define __ASSUME_PREADV 1
+ #define __ASSUME_PWRITEV 1
+
+-/* Support for FUTEX_*_REQUEUE_PI was added in 2.6.31 (but some
+- architectures lack futex_atomic_cmpxchg_inatomic in some
+- configurations). */
+-#define __ASSUME_REQUEUE_PI 1
+-
+ /* Support for recvmmsg functionality was added in 2.6.33. The macros
+ defined correspond to those for accept4. */
+ #if __LINUX_KERNEL_VERSION >= 0x020621
+diff --git a/sysdeps/unix/sysv/linux/m68k/kernel-features.h b/sysdeps/unix/sysv/linux/m68k/kernel-features.h
+index 46ec601..174c1c6 100644
+--- a/sysdeps/unix/sysv/linux/m68k/kernel-features.h
++++ b/sysdeps/unix/sysv/linux/m68k/kernel-features.h
+@@ -51,6 +51,5 @@
+
+ /* No support for PI futexes or robust mutexes before 3.10 for m68k. */
+ #if __LINUX_KERNEL_VERSION < 0x030a00
+-# undef __ASSUME_REQUEUE_PI
+ # undef __ASSUME_SET_ROBUST_LIST
+ #endif
+diff --git a/sysdeps/unix/sysv/linux/mips/kernel-features.h b/sysdeps/unix/sysv/linux/mips/kernel-features.h
+index b486d90..a795911c 100644
+--- a/sysdeps/unix/sysv/linux/mips/kernel-features.h
++++ b/sysdeps/unix/sysv/linux/mips/kernel-features.h
+@@ -24,7 +24,6 @@
+ /* The MIPS kernel does not support futex_atomic_cmpxchg_inatomic if
+ emulating LL/SC. */
+ #if __mips == 1 || defined _MIPS_ARCH_R5900
+-# undef __ASSUME_REQUEUE_PI
+ # undef __ASSUME_SET_ROBUST_LIST
+ #endif
+
+diff --git a/sysdeps/unix/sysv/linux/sparc/kernel-features.h b/sysdeps/unix/sysv/linux/sparc/kernel-features.h
+index 69c9c7c..dd3ddf0 100644
+--- a/sysdeps/unix/sysv/linux/sparc/kernel-features.h
++++ b/sysdeps/unix/sysv/linux/sparc/kernel-features.h
+@@ -34,6 +34,5 @@
+ /* 32-bit SPARC kernels do not support
+ futex_atomic_cmpxchg_inatomic. */
+ #if !defined __arch64__ && !defined __sparc_v9__
+-# undef __ASSUME_REQUEUE_PI
+ # undef __ASSUME_SET_ROBUST_LIST
+ #endif
+--
+2.10.2
+
diff --git a/meta/recipes-core/glibc/glibc/0006-Fix-atomic_fetch_xor_release.patch b/meta/recipes-core/glibc/glibc/0006-Fix-atomic_fetch_xor_release.patch
new file mode 100644
index 0000000..7616efa
--- /dev/null
+++ b/meta/recipes-core/glibc/glibc/0006-Fix-atomic_fetch_xor_release.patch
@@ -0,0 +1,81 @@
+From b671f20cc160238b62894d032a55baf85867106e Mon Sep 17 00:00:00 2001
+From: Catalin Enache <catalin.enache at windriver.com>
+Date: Fri, 30 Jun 2017 19:12:43 +0300
+Subject: [PATCH 6/6] Fix atomic_fetch_xor_release.
+
+No code uses atomic_fetch_xor_release except for the upcoming
+conditional variable rewrite. Therefore there is no user
+visible bug here. The use of atomic_compare_and_exchange_bool_rel
+is removed (since it doesn't exist anymore), and is replaced
+by atomic_compare_exchange_weak_release.
+
+We use weak_release because it provides better performance in
+the loop (the weak semantic) and because the xor is release MO
+(the release semantic). We don't reload expected in the loop
+because atomic_compare_and_exchange_weak_release does this for
+us as part of the CAS failure.
+
+It is otherwise a fairly plain conversion that fixes building
+the new condvar for 32-bit x86. Passes all regression tests
+for x86.
+
+Upstream-Status: Backport
+
+Author: Carlos O'Donell <carlos at systemhalted.org>
+Signed-off-by: Catalin Enache <catalin.enache at windriver.com>
+---
+ ChangeLog | 6 ++++++
+ include/atomic.h | 19 +++++++++++--------
+ 2 files changed, 17 insertions(+), 8 deletions(-)
+
+diff --git a/ChangeLog b/ChangeLog
+index 44c518b..893262d 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,9 @@
++2016-10-26 Carlos O'Donell <carlos at redhat.com>
++
++ * include/atomic.h
++ [USE_COMPILER_ATOMIC_BUILTINS && !atomic_fetch_xor_release]
++ (atomic_fetch_xor_release): Use atomic_compare_exchange_weak_release.
++
+ 2017-04-04 Adhemerval Zanella <adhemerval.zanella at linaro.org>
+
+ * nptl/pthreadP.h (USE_REQUEUE_PI): Remove ununsed macro.
+diff --git a/include/atomic.h b/include/atomic.h
+index 5a8e7e7..c8b4664 100644
+--- a/include/atomic.h
++++ b/include/atomic.h
+@@ -777,18 +777,21 @@ void __atomic_link_error (void);
+ # endif
+
+ # ifndef atomic_fetch_xor_release
++/* Failing the atomic_compare_exchange_weak_release reloads the value in
++ __atg104_expected, so we need only do the XOR again and retry. */
+ # define atomic_fetch_xor_release(mem, operand) \
+- ({ __typeof (*(mem)) __atg104_old; \
+- __typeof (mem) __atg104_memp = (mem); \
++ ({ __typeof (mem) __atg104_memp = (mem); \
++ __typeof (*(mem)) __atg104_expected = (*__atg104_memp); \
++ __typeof (*(mem)) __atg104_desired; \
+ __typeof (*(mem)) __atg104_op = (operand); \
+ \
+ do \
+- __atg104_old = (*__atg104_memp); \
+- while (__builtin_expect \
+- (atomic_compare_and_exchange_bool_rel ( \
+- __atg104_memp, __atg104_old ^ __atg104_op, __atg104_old), 0));\
+- \
+- __atg104_old; })
++ __atg104_desired = __atg104_expected ^ __atg104_op; \
++ while (__glibc_unlikely \
++ (atomic_compare_exchange_weak_release ( \
++ __atg104_memp, &__atg104_expected, __atg104_desired) \
++ == 0)); \
++ __atg104_expected; })
+ #endif
+
+ #endif /* !USE_ATOMIC_COMPILER_BUILTINS */
+--
+2.10.2
+
diff --git a/meta/recipes-core/glibc/glibc_2.24.bb b/meta/recipes-core/glibc/glibc_2.24.bb
index 08ae459..e723e03 100644
--- a/meta/recipes-core/glibc/glibc_2.24.bb
+++ b/meta/recipes-core/glibc/glibc_2.24.bb
@@ -39,6 +39,12 @@ SRC_URI = "${GLIBC_GIT_URI};branch=${SRCBRANCH};name=glibc \
file://0026-build_local_scope.patch \
file://0028-Bug-20116-Fix-use-after-free-in-pthread_create.patch \
file://CVE-2016-6323.patch \
+ file://0001-Add-atomic_exchange_relaxed.patch \
+ file://0002-Add-atomic-operations-required-by-the-new-condition-.patch \
+ file://0003-Add-pretty-printers-for-the-NPTL-lock-types.patch \
+ file://0004-New-condvar-implementation-that-provides-stronger-or.patch \
+ file://0005-Remove-__ASSUME_REQUEUE_PI.patch \
+ file://0006-Fix-atomic_fetch_xor_release.patch \
"
SRC_URI += "\
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
More information about the Openembedded-commits
mailing list