Re: [crux-arm] [patch] glibc: updated to 2.24-10

29 Jan 2018

* Fredrik Rinnestam (fredrik@rinnestam.se) wrote:
...
patch attached
--
Fredrik Rinnestam
Thank you very much for the patch Fredrik.
Patch applied:
https://crux-arm.nu/gitweb?p=ports/core-arm.git;a=commit;h=e308f0f7f24c3fa18...
...
From ec44de2f3c35100b701e3619eda26233dfa9bd00 Mon Sep 17 00:00:00 2001
From: Fredrik Rinnestam <fredrik@rinnestam.se>
Date: Sat, 27 Jan 2018 20:58:22 +0100
Subject: [PATCH] glibc: updated to 2.24-10
---
 glibc/.footprint                |     1 -
 glibc/.md5sum                   |     1 +
 glibc/Pkgfile                   |    88 +-
 glibc/glibc-2.24-10.patch       | 19308 ++++++++++++++++++++++++++++++++++++++
 glibc/iconv-gconv_trans.c.patch |   192 -
 5 files changed, 19353 insertions(+), 237 deletions(-)
 create mode 100644 glibc/glibc-2.24-10.patch
 delete mode 100644 glibc/iconv-gconv_trans.c.patch

diff --git a/glibc/.footprint b/glibc/.footprint
index e0b53e4..d4fef4c 100644
--- a/glibc/.footprint
+++ b/glibc/.footprint
@@ -342,7 +342,6 @@ drwxr-xr-x	root/root	usr/include/gnu/
 -rw-r--r--	root/root	usr/include/gnu/lib-names.h
 -rw-r--r--	root/root	usr/include/gnu/libc-version.h
 -rw-r--r--	root/root	usr/include/gnu/stubs-hard.h
-lrwxrwxrwx	root/root	usr/include/gnu/stubs-soft.h -> stubs-hard.h
 -rw-r--r--	root/root	usr/include/gnu/stubs.h
 -rw-r--r--	root/root	usr/include/grp.h
 -rw-r--r--	root/root	usr/include/gshadow.h
diff --git a/glibc/.md5sum b/glibc/.md5sum
index df9b2fe..da726e6 100644
--- a/glibc/.md5sum
+++ b/glibc/.md5sum
@@ -1,3 +1,4 @@
+4382c5b030a4995a9a4649dd735f6685  glibc-2.24-10.patch
 97dc5517f92016f3d70d83e3162ad318  glibc-2.24.tar.xz
 96156bec8e05de67384dc93e72bdc313  host.conf
 fbbc215a9b15ba4846f326cc88108057  hosts
diff --git a/glibc/Pkgfile b/glibc/Pkgfile
index b99bc98..1e983be 100644
--- a/glibc/Pkgfile
+++ b/glibc/Pkgfile
@@ -1,51 +1,51 @@
 # Description: The C library used in the GNU system
-# URL: http://www.gnu.org/software/libc/
-# Maintainer: CRUX System Team, core-ports at crux dot nu
-# Arch Maintainer: CRUX-ARM System Team, devel at crux-arm dot nu
-# Depends on:
+# URL:         http://www.gnu.org/software/libc/
+# Maintainer:  CRUX System Team, core-ports at crux dot nu
name=glibc
 version=2.24
-release=3
-source=(http://ftp.gnu.org/gnu/glibc/glibc-$version.tar.xz \
-        http://ftp.kernel.org/pub/linux/kernel/v4.x/linux-4.1.13.tar.xz \
-        hosts resolv.conf nsswitch.conf host.conf ld.so.conf)
+release=10
+source=(http://ftpmirror.gnu.org/gnu/glibc/glibc-2.24.tar.xz \
+	http://www.kernel.org/pub/linux/kernel/v4.x/linux-4.1.13.tar.xz \
+	hosts resolv.conf nsswitch.conf host.conf ld.so.conf \
+	glibc-2.24-10.patch)
build() {
-  # install kernel headers
-  cd linux-4.1.13
-  make mrproper
-  make ARCH=arm headers_check
-  make ARCH=arm INSTALL_HDR_PATH=$PKG/usr headers_install
-
-  mkdir $SRC/build
-  cd $SRC/build
-  ../$name-$version/configure --prefix=/usr \
-                              --build=arm-unknown-linux-gnueabihf \
-                              --libexecdir=/usr/lib \
-                              --with-headers=$PKG/usr/include \
-                              --enable-kernel=2.6.25 \
-                              --enable-add-ons \
-                              --enable-static-nss \
-                              --disable-profile \
-                              --disable-werror \
-                              --without-gd \
-                              --enable-obsolete-rpc
-
-  make
-  make install_root=$PKG install
-
-  install -m 0644 $SRC/$name-$version/nscd/nscd.conf $PKG/etc
-  install -d $PKG/var/{db,run}/nscd
-
-  install -m 0644 $SRC/{hosts,resolv.conf,nsswitch.conf,host.conf,ld.so.conf} $PKG/etc
-
-  ln -sf ../usr/share/zoneinfo/UTC $PKG/etc/localtime
-	ln -s stubs-hard.h $PKG/usr/include/gnu/stubs-soft.h
-  install -d $PKG/etc/ld.so.conf.d $PKG/usr/lib/locale
-  touch $PKG/etc/ld.so.cache
-
-  rm -rf $PKG/usr/share/{info,locale} \
-        $PKG/usr/bin/tzselect \
-        $PKG/usr/sbin/z{dump,ic}
+	# install kernel headers
+	cd linux-4.1.13
+	make mrproper
+	make ARCH=arm headers_check
+	make ARCH=arm INSTALL_HDR_PATH=$PKG/usr headers_install
+
+	patch -p1 -d $SRC/$name-${version:0:4} -i $SRC/glibc-2.24-10.patch
+
+	mkdir $SRC/build
+	cd $SRC/build
+	../$name-${version:0:4}/configure --prefix=/usr \
+		--build=arm-unknown-linux-gnueabihf \
+		--libexecdir=/usr/lib \
+		--with-headers=$PKG/usr/include \
+		--enable-kernel=2.6.25 \
+		--enable-add-ons \
+		--enable-static-nss \
+		--disable-profile \
+		--disable-werror \
+		--without-gd \
+		--enable-obsolete-rpc
+	make 
+	#make check
+	make install_root=$PKG install
+
+	install -m 0644 $SRC/$name-${version:0:4}/nscd/nscd.conf $PKG/etc 
+	install -d $PKG/var/{db,run}/nscd
+
+	install -m 0644 $SRC/{hosts,resolv.conf,nsswitch.conf,host.conf,ld.so.conf} $PKG/etc
+
+	ln -sf ../usr/share/zoneinfo/UTC $PKG/etc/localtime
+	install -d $PKG/etc/ld.so.conf.d $PKG/usr/lib/locale
+	touch $PKG/etc/ld.so.cache
+
+	rm -rf $PKG/usr/share/{info,locale} \
+		$PKG/usr/bin/tzselect \
+		$PKG/usr/sbin/z{dump,ic}
 }
diff --git a/glibc/glibc-2.24-10.patch b/glibc/glibc-2.24-10.patch
new file mode 100644
index 0000000..194691d
--- /dev/null
+++ b/glibc/glibc-2.24-10.patch
@@ -0,0 +1,19308 @@
+diff --git a/ChangeLog b/ChangeLog
+index c44c926094..cd499c5fe3 100644
+--- a/ChangeLog
++++ b/ChangeLog
+@@ -1,3 +1,887 @@
++2018-01-12  Dmitry V. Levin  <ldv@altlinux.org>
++
++	[BZ #22679]
++	CVE-2018-1000001
++	* sysdeps/unix/sysv/linux/getcwd.c (__getcwd): Fall back to
++	generic_getcwd if the path returned by getcwd syscall is not absolute.
++	* io/tst-getcwd-abspath.c: New test.
++	* io/Makefile (tests): Add tst-getcwd-abspath.
++
++	(gaih_inet): Likewise.
++
++2017-12-30  Aurelien Jarno  <aurelien@aurel32.net>
++
++	[BZ #22625]
++	* elf/dl-load.c (fillin_rpath): Check for empty tokens before dynamic
++	string token expansion. Check for NULL pointer or empty string possibly
++	returned by expand_dynamic_string_token.
++	(decompose_rpath): Check for empty path after dynamic string
++	token expansion.
++
++2017-12-18  Dmitry V. Levin  <ldv@altlinux.org>
++
++	[BZ #22627]
++	* elf/dl-load.c (_dl_init_paths): Remove _dl_dst_substitute preparatory
++	code and invocation.
++
++2017-12-14  Florian Weimer  <fweimer@redhat.com>
++
++	[BZ #22607]
++	CVE-2017-1000409
++	* elf/dl-load.c (_dl_init_paths): Compute number of components in
++	the expanded path string.
++
++2017-12-14  Florian Weimer  <fweimer@redhat.com>
++
++	[BZ #22606]
++	CVE-2017-1000408
++	* elf/dl-load.c (system_dirs): Update comment.
++	(nsystem_dirs_len): Use array_length.
++	(_dl_init_paths): Use nsystem_dirs_len to compute the array size.
++
++2017-11-02  Florian Weimer  <fweimer@redhat.com>
++
++	Add array_length and array_end macros.
++	* include/array_length.h: New file.
++
++2017-11-02  Florian Weimer  <fweimer@redhat.com>
++
++	[BZ #22332]
++	* posix/tst-glob-tilde.c (do_noescape): New variable.
++	(one_test): Process it.
++	(do_test): Set do_noescape.  Add unescaping test case.
++
++2017-10-22  Paul Eggert <eggert@cs.ucla.edu>
++
++	[BZ #22332]
++	* posix/glob.c (__glob): Fix buffer overflow during GLOB_TILDE
++	unescaping.
++
++2017-10-21  Florian Weimer  <fweimer@redhat.com>
++
++	* posix/Makefile (tests): Add tst-glob-tilde.
++	(tests-special): Add tst-glob-tilde-mem.out
++	(tst-glob-tilde-ENV): Set MALLOC_TRACE.
++	(tst-glob-tilde-mem.out): Add mtrace check.
++	* posix/tst-glob-tilde.c: New file.
++
++2017-10-20  Paul Eggert <eggert@cs.ucla.edu>
++
++	[BZ #22320]
++	CVE-2017-15670
++	* posix/glob.c (__glob): Fix one-byte overflow.
++
++2017-09-08  Adhemerval Zanella  <adhemerval.zanella@linaro.org>
++
++	[BZ #1062]
++	CVE-2017-15671
++	* posix/Makefile (routines): Add globfree, globfree64, and
++	glob_pattern_p.
++	* posix/flexmember.h: New file.
++	* posix/glob_internal.h: Likewise.
++	* posix/glob_pattern_p.c: Likewise.
++	* posix/globfree.c: Likewise.
++	* posix/globfree64.c: Likewise.
++	* sysdeps/gnu/globfree64.c: Likewise.
++	* sysdeps/unix/sysv/linux/alpha/globfree.c: Likewise.
++	* sysdeps/unix/sysv/linux/mips/mips64/n64/globfree64.c: Likewise.
++	* sysdeps/unix/sysv/linux/oldglob.c: Likewise.
++	* sysdeps/unix/sysv/linux/wordsize-64/globfree64.c: Likewise.
++	* sysdeps/unix/sysv/linux/x86_64/x32/globfree.c: Likewise.
++	* sysdeps/wordsize-64/globfree.c: Likewise.
++	* sysdeps/wordsize-64/globfree64.c: Likewise.
++	* posix/glob.c (HAVE_CONFIG_H): Use !_LIBC instead.
++	[NDEBUG): Remove comments.
++	(GLOB_ONLY_P, _AMIGA, VMS): Remove define.
++	(dirent_type): New type.  Use uint_fast8_t not
++	uint8_t, as C99 does not require uint8_t.
++	(DT_UNKNOWN, DT_DIR, DT_LNK): New macros.
++	(struct readdir_result): Use dirent_type.  Do not define skip_entry
++	unless it is needed; this saves a byte on platforms lacking d_ino.
++	(readdir_result_type, readdir_result_skip_entry):
++	New functions, replacing ...
++	(readdir_result_might_be_symlink, readdir_result_might_be_dir):
++	 these functions, which were removed.  This makes the callers
++	easier to read.  All callers changed.
++	(D_INO_TO_RESULT): Now empty if there is no d_ino.
++	(size_add_wrapv, glob_use_alloca): New static functions.
++	(glob, glob_in_dir): Check for size_t overflow in several places,
++	and fix some size_t checks that were not quite right.
++	Remove old code using SHELL since Bash no longer
++	uses this.
++	(glob, prefix_array): Separate MS code better.
++	(glob_in_dir): Remove old Amiga and VMS code.
++	(globfree, __glob_pattern_type, __glob_pattern_p): Move to
++	separate files.
++	(glob_in_dir): Do not rely on undefined behavior in accessing
++	struct members beyond their bounds.  Use a flexible array member
++	instead
++	(link_stat): Rename from link_exists2_p and return -1/0 instead of
++	0/1.  Caller changed.
++	(glob): Fix memory leaks.
++	* posix/glob64 (globfree64): Move to separate file.
++	* sysdeps/gnu/glob64.c (NO_GLOB_PATTERN_P): Remove define.
++	(globfree64): Remove hidden alias.
++	* sysdeps/unix/sysv/linux/Makefile (sysdeps_routines): Add
++	oldglob.
++	* sysdeps/unix/sysv/linux/alpha/glob.c (__new_globfree): Move to
++	separate file.
++	* sysdeps/unix/sysv/linux/i386/glob64.c (NO_GLOB_PATTERN_P): Remove
++	define.
++	Move compat code to separate file.
++	* sysdeps/wordsize-64/glob.c (globfree): Move definitions to
++	separate file.
++
++2017-08-20  H.J. Lu  <hongjiu.lu@intel.com>
++
++	[BZ #18822]
++	* sysdeps/unix/sysv/linux/i386/glob64.c (__old_glob64): Add
++	libc_hidden_proto and libc_hidden_def.
++
++2017-10-22  H.J. Lu  <hongjiu.lu@intel.com>
++
++	[BZ #21265]
++	* sysdeps/x86/cpu-features-offsets.sym (XSAVE_STATE_SIZE_OFFSET):
++	New.
++	* sysdeps/x86/cpu-features.c: Include <libc-internal.h>.
++	(get_common_indeces): Set xsave_state_size and
++	bit_arch_XSAVEC_Usable if needed.
++	(init_cpu_features): Remove bit_arch_Use_dl_runtime_resolve_slow
++	and bit_arch_Use_dl_runtime_resolve_opt.
++	* sysdeps/x86/cpu-features.h (bit_arch_Use_dl_runtime_resolve_opt):
++	Removed.
++	(bit_arch_Use_dl_runtime_resolve_slow): Likewise.
++	(bit_arch_Prefer_No_AVX512): Updated.
++	(bit_arch_MathVec_Prefer_No_AVX512): Likewise.
++	(bit_arch_XSAVEC_Usable): New.
++	(STATE_SAVE_OFFSET): Likewise.
++	(STATE_SAVE_MASK): Likewise.
++	[__ASSEMBLER__]: Include <cpu-features-offsets.h>.
++	(cpu_features): Add xsave_state_size.
++	(index_arch_Use_dl_runtime_resolve_opt): Removed.
++	(index_arch_Use_dl_runtime_resolve_slow): Likewise.
++	(index_arch_XSAVEC_Usable): New.
++	* sysdeps/x86_64/dl-machine.h (elf_machine_runtime_setup):
++	Replace _dl_runtime_resolve_sse, _dl_runtime_resolve_avx,
++	_dl_runtime_resolve_avx_slow, _dl_runtime_resolve_avx_opt,
++	_dl_runtime_resolve_avx512 and _dl_runtime_resolve_avx512_opt
++	with _dl_runtime_resolve_fxsave, _dl_runtime_resolve_xsave and
++	_dl_runtime_resolve_xsavec.
++	* sysdeps/x86_64/dl-trampoline.S (DL_RUNTIME_UNALIGNED_VEC_SIZE):
++	Removed.
++	(DL_RUNTIME_RESOLVE_REALIGN_STACK): Check STATE_SAVE_ALIGNMENT
++	instead of VEC_SIZE.
++	(REGISTER_SAVE_BND0): Removed.
++	(REGISTER_SAVE_BND1): Likewise.
++	(REGISTER_SAVE_BND3): Likewise.
++	(REGISTER_SAVE_RAX): Always defined to 0.
++	(VMOV): Removed.
++	(_dl_runtime_resolve_avx): Likewise.
++	(_dl_runtime_resolve_avx_slow): Likewise.
++	(_dl_runtime_resolve_avx_opt): Likewise.
++	(_dl_runtime_resolve_avx512): Likewise.
++	(_dl_runtime_resolve_avx512_opt): Likewise.
++	(_dl_runtime_resolve_sse): Likewise.
++	(_dl_runtime_resolve_sse_vex): Likewise.
++	(USE_FXSAVE): New.
++	(_dl_runtime_resolve_fxsave): Likewise.
++	(USE_XSAVE): Likewise.
++	(_dl_runtime_resolve_xsave): Likewise.
++	(USE_XSAVEC): Likewise.
++	(_dl_runtime_resolve_xsavec): Likewise.
++	* sysdeps/x86_64/dl-trampoline.h (_dl_runtime_resolve_avx512):
++	Removed.
++	(_dl_runtime_resolve_avx512_opt): Likewise.
++	(_dl_runtime_resolve_avx): Likewise.
++	(_dl_runtime_resolve_avx_opt): Likewise.
++	(_dl_runtime_resolve_sse): Likewise.
++	(_dl_runtime_resolve_sse_vex): Likewise.
++	(_dl_runtime_resolve_fxsave): New.
++	(_dl_runtime_resolve_xsave): Likewise.
++	(_dl_runtime_resolve_xsavec): Likewise.
++
++2017-10-19  H.J. Lu  <hongjiu.lu@intel.com>
++
++	* sysdeps/x86_64/Makefile (tests): Add tst-sse, tst-avx and
++	tst-avx512.
++	(test-extras): Add tst-avx-aux and tst-avx512-aux.
++	(extra-test-objs): Add tst-avx-aux.o and tst-avx512-aux.o.
++	(modules-names): Add tst-ssemod, tst-avxmod and tst-avx512mod.
++	($(objpfx)tst-sse): New rule.
++	($(objpfx)tst-avx): Likewise.
++	($(objpfx)tst-avx512): Likewise.
++	(CFLAGS-tst-avx-aux.c): New.
++	(CFLAGS-tst-avxmod.c): Likewise.
++	(CFLAGS-tst-avx512-aux.c): Likewise.
++	(CFLAGS-tst-avx512mod.c): Likewise.
++	* sysdeps/x86_64/tst-avx-aux.c: New file.
++	* sysdeps/x86_64/tst-avx.c: Likewise.
++	* sysdeps/x86_64/tst-avx512-aux.c: Likewise.
++	* sysdeps/x86_64/tst-avx512.c: Likewise.
++	* sysdeps/x86_64/tst-avx512mod.c: Likewise.
++	* sysdeps/x86_64/tst-avxmod.c: Likewise.
++	* sysdeps/x86_64/tst-sse.c: Likewise.
++	* sysdeps/x86_64/tst-ssemod.c: Likewise.
++
++2017-10-19  H.J. Lu  <hongjiu.lu@intel.com>
++
++	* sysdeps/x86_64/dl-trampoline.h (_dl_runtime_resolve): Don't
++	adjust CFA when allocating register save area on re-aligned
++	stack.
++
++2016-12-21  Joseph Myers  <joseph@codesourcery.com>
++
++	[BZ #20978]
++	* nis/nss_nisplus/nisplus-alias.c (_nss_nisplus_getaliasbyname_r):
++	Compare name == NULL, not name != NULL.
++
++2016-11-08  Joseph Myers  <joseph@codesourcery.com>
++
++	[BZ #20790]
++	* sunrpc/rpc_parse.c (get_prog_declaration): Increase buffer size
++	to MAXLINESIZE.
++	* sunrpc/bug20790.x: New file.
++	* sunrpc/Makefile [$(run-built-tests) = yes] (rpcgen-tests): New
++	variable.
++	[$(run-built-tests) = yes] (tests-special): Add $(rpcgen-tests).
++	[$(run-built-tests) = yes] ($(rpcgen-tests)): New rule.
++
++2016-10-14  Steve Ellcey  <sellcey@caviumnetworks.com>
++
++	* sysdeps/ieee754/dbl-64/e_pow.c (checkint) Make conditions explicitly
++	boolean.
++
++2017-07-19  DJ Delorie  <dj@delorie.com>
++
++	[BZ #21654]
++	* grp/grp-merge.c (libc_hidden_def): Fix cast-after-dereference.
++
++2017-07-14  DJ Delorie  <dj@redhat.com>
++
++	[BZ #21654]
++	* grp/grp_merge.c (__copy_grp): Align char** to minimum pointer
++	alignment not char alignment.
++	(__merge_grp): Likewise.
++
++2017-08-06  H.J. Lu  <hongjiu.lu@intel.com>
++
++	[BZ #21871]
++	* sysdeps/x86/cpu-features.c (init_cpu_features): Set
++	bit_arch_Use_dl_runtime_resolve_opt only with AVX512F.
++
++2017-02-27  Florian Weimer  <fweimer@redhat.com>
++
++	[BZ #21115]
++	* sunrpc/clnt_udp.c (clntudp_call): Free ancillary data later.
++	* sunrpc/Makefile (tests): Add tst-udp-error.
++	(tst-udp-error): Link against libc.so explicitly.
++	* sunrpc/tst-udp-error: New file.
++
++2017-01-24  James Clarke  <jrtc27@jrtc27.com>
++
++	* sysdeps/unix/sysv/linux/sh/sh3/ucontext_i.sym: Use new REG_R*
++	constants instead of the old R* ones.
++	* sysdeps/unix/sysv/linux/sh/sh4/ucontext_i.sym: Likewise.
++	* sysdeps/unix/sysv/linux/sh/sys/ucontext.h (NGPREG): Rename...
++	(NGREG): ... to this, to fit in with other architectures.
++	(gpregset_t): Use new NGREG macro.
++	[__USE_GNU]: Remove condition; all architectures other than tile
++	are unconditional.
++	(R*): Rename to REG_R*.
++
++2017-07-26  H.J. Lu  <hongjiu.lu@intel.com>
++
++	[BZ #21666]
++	* misc/regexp.c (loc1): Add __attribute__ ((nocommon));
++	(loc2): Likewise.
++	(locs): Likewise.
++
++2017-07-12  Szabolcs Nagy  <szabolcs.nagy@arm.com>
++
++	* sysdeps/aarch64/dl-machine.h (RTLD_START_1): Change _dl_argv to the
++	hidden __GI__dl_argv symbol.
++
++2016-09-05  Aurelien Jarno  <aurelien@aurel32.net>
++
++	* conform/Makefile (conformtest-header-tests): Pass -I. to $(PERL).
++	(linknamespace-symlists-tests): Likewise.
++	(linknamespace-header-tests): Likewise.
++
++2017-07-06  Florian Weimer  <fweimer@redhat.com>
++	    H.J. Lu  <hongjiu.lu@intel.com>
++
++	[BZ #21609]
++	* sysdeps/x86_64/Makefile (sysdep-dl-routines): Add tls_get_addr.
++	(gen-as-const-headers): Add rtld-offsets.sym.
++	* sysdeps/x86_64/dl-tls.c: New file.
++	* sysdeps/x86_64/rtld-offsets.sym: Likwise.
++	* sysdeps/x86_64/tls_get_addr.S: Likewise.
++	* sysdeps/x86_64/dl-tls.h: Add multiple inclusion guards.
++	* sysdeps/x86_64/tlsdesc.sym (TI_MODULE_OFFSET): New.
++	(TI_OFFSET_OFFSET): Likwise.
++
++2017-06-14  Florian Weimer  <fweimer@redhat.com>
++
++	* sysdeps/i386/i686/multiarch/strcspn-c.c: Add IS_IN (libc) guard.
++	* sysdeps/i386/i686/multiarch/varshift.c: Likewise.
++
++2017-03-07  Siddhesh Poyarekar  <siddhesh@sourceware.org>
++
++	[BZ #21209]
++	* elf/rtld.c (process_envvars): Ignore LD_HWCAP_MASK for
++	AT_SECURE processes.
++	* sysdeps/generic/unsecvars.h: Add LD_HWCAP_MASK.
++
++2017-06-19  Florian Weimer  <fweimer@redhat.com>
++
++	* elf/rtld.c (audit_list_string): New variable.
++	(audit_list): Update comment.
++	(struct audit_list_iter): Define.
++	(audit_list_iter_init, audit_list_iter_next): New function.
++	(dl_main): Use struct audit_list_iter to process audit modules.
++	(process_dl_audit): Call dso_name_valid_for_suid.
++	(process_envvars): Set audit_list_string instead of calling
++	process_dl_audit.
++
++2017-06-19  Florian Weimer  <fweimer@redhat.com>
++
++	* elf/rtld.c (SECURE_NAME_LIMIT, SECURE_PATH_LIMIT): Define.
++	(dso_name_valid_for_suid): New function.
++	(handle_ld_preload): Likewise.
++	(dl_main): Call it.  Remove alloca.
++
++2017-06-19  Florian Weimer  <fweimer@redhat.com>
++
++	[BZ #21624]
++	CVE-2017-1000366
++	* elf/rtld.c (process_envvars): Ignore LD_LIBRARY_PATH for
++	__libc_enable_secure.
++
++2017-02-01  Andreas Schwab  <schwab@linux-m68k.org>
++
++	* sysdeps/m68k/m680x0/m68020/atomic-machine.h
++	(__arch_compare_and_exchange_val_64_acq, atomic_exchange_acq)
++	(atomic_exchange_and_add, atomic_add): Add casts to 64 bit asm
++	operands.
++
++2017-05-12  Florian Weimer  <fweimer@redhat.com>
++
++	[BZ #21386]
++	* sysdeps/nptl/fork.c (__libc_fork): Remove assertions on the
++	parent PID.  The assertion in the child is incorrect with PID
++	namespaces.
++
++2017-06-07  Arjun Shankar  <arjun.is@lostca.se>
++
++	* sysdeps/unix/sysv/linux/tst-clone2.c: Do not
++	include test-skeleton.c.
++	Include support/check.h and support/test-driver.c.
++
++2016-11-24  Adhemerval Zanella  <adhemerval.zanella@linaro.org>
++
++	* sysdeps/nptl/fork.c (__libc_fork): Remove pid cache setting.
++	* nptl/allocatestack.c (allocate_stack): Likewise.
++	(__reclaim_stacks): Likewise.
++	(setxid_signal_thread): Obtain pid through syscall.
++	* nptl/nptl-init.c (sigcancel_handler): Likewise.
++	(sighandle_setxid): Likewise.
++	* nptl/pthread_cancel.c (pthread_cancel): Likewise.
++	* sysdeps/unix/sysv/linux/pthread_kill.c (__pthread_kill): Likewise.
++	* sysdeps/unix/sysv/linux/pthread_sigqueue.c (pthread_sigqueue):
++	Likewise.
++	* sysdeps/unix/sysv/linux/createthread.c (create_thread): Likewise.
++	* sysdeps/unix/sysv/linux/raise.c (raise): Remove old behaviour
++	comment.
++	* sysdeps/unix/sysv/linux/getpid.c: Remove file.
++	* nptl/descr.h (struct pthread): Change comment about pid value.
++	* nptl/pthread_getattr_np.c (pthread_getattr_np): Remove thread
++	pid assert.
++	* sysdeps/unix/sysv/linux/pthread-pids.h (__pthread_initialize_pids):
++	Do not set pid value.
++	* nptl_db/td_ta_thr_iter.c (iterate_thread_list): Remove thread
++	pid cache check.
++	* nptl_db/td_thr_validate.c (td_thr_validate): Likewise.
++	* sysdeps/aarch64/nptl/tcb-offsets.sym: Remove pid offset.
++	* sysdeps/alpha/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/arm/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/hppa/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/i386/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/ia64/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/m68k/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/microblaze/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/mips/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/nios2/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/powerpc/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/s390/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/sh/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/sparc/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/tile/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/x86_64/nptl/tcb-offsets.sym: Likewise.
++	* sysdeps/unix/sysv/linux/aarch64/clone.S: Remove pid and tid caching.
++	* sysdeps/unix/sysv/linux/alpha/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/arm/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/hppa/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/i386/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/ia64/clone2.S: Likewise.
++	* sysdeps/unix/sysv/linux/mips/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/nios2/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/powerpc/powerpc32/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/powerpc/powerpc64/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/s390/s390-32/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/s390/s390-64/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/sh/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/sparc/sparc32/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/sparc/sparc64/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/tile/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/x86_64/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/aarch64/vfork.S: Remove pid set and reset.
++	* sysdeps/unix/sysv/linux/alpha/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/arm/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/i386/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/ia64/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/m68k/clone.S: Likewise.
++	* sysdeps/unix/sysv/linux/m68k/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/mips/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/nios2/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/powerpc/powerpc32/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/powerpc/powerpc64/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/s390/s390-32/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/s390/s390-64/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/sh/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/sparc/sparc32/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/sparc/sparc64/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/tile/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/x86_64/vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/hppa/pt-vfork.S: Likewise.
++	* sysdeps/unix/sysv/linux/tst-clone2.c (f): Remove direct pthread
++	struct access.
++	(clone_test): Remove function.
++	(do_test): Rewrite to take in consideration pid is not cached anymore.
++
++2016-09-26  Adhemerval Zanella  <adhemerval.zanella@linaro.org>
++
++	* sysdeps/unix/sysdep.h (__INTERNAL_SYSCALL0): New macro.
++	(__INTERNAL_SYSCALL1): Likewise.
++	(__INTERNAL_SYSCALL2): Likewise.
++	(__INTERNAL_SYSCALL3): Likewise.
++	(__INTERNAL_SYSCALL4): Likewise.
++	(__INTERNAL_SYSCALL5): Likewise.
++	(__INTERNAL_SYSCALL6): Likewise.
++	(__INTERNAL_SYSCALL7): Likewise.
++	(__INTERNAL_SYSCALL_NARGS_X): Likewise.
++	(__INTERNAL_SYSCALL_NARGS): Likewise.
++	(__INTERNAL_SYSCALL_DISP): Likewise.
++	(INTERNAL_SYSCALL_CALL): Likewise.
++	(__SYSCALL0): Rename to __INLINE_SYSCALL0.
++	(__SYSCALL1): Rename to __INLINE_SYSCALL1.
++	(__SYSCALL2): Rename to __INLINE_SYSCALL2.
++	(__SYSCALL3): Rename to __INLINE_SYSCALL3.
++	(__SYSCALL4): Rename to __INLINE_SYSCALL4.
++	(__SYSCALL5): Rename to __INLINE_SYSCALL5.
++	(__SYSCALL6): Rename to __INLINE_SYSCALL6.
++	(__SYSCALL7): Rename to __INLINE_SYSCALL7.
++	(__SYSCALL_NARGS_X): Rename to __INLINE_SYSCALL_NARGS_X.
++	(__SYSCALL_NARGS): Rename to __INLINE_SYSCALL_NARGS.
++	(__SYSCALL_DISP): Rename to __INLINE_SYSCALL_DISP.
++	(__SYSCALL_CALL): Rename to INLINE_SYSCALL_CALL.
++	(SYSCALL_CANCEL): Replace __SYSCALL_CALL with INLINE_SYSCALL_CALL.
++
++2017-04-28  H.J. Lu  <hongjiu.lu@intel.com>
++
++	[BZ #21396]
++	* sysdeps/x86/cpu-features.c (init_cpu_features): Set
++	Prefer_No_AVX512 if AVX512ER isn't available.
++	* sysdeps/x86/cpu-features.h (bit_arch_Prefer_No_AVX512): New.
++	(index_arch_Prefer_No_AVX512): Likewise.
++	* sysdeps/x86_64/multiarch/memcpy.S (__new_memcpy): Don't use
++	AVX512 version if Prefer_No_AVX512 is set.
++	* sysdeps/x86_64/multiarch/memcpy_chk.S (__memcpy_chk):
++	Likewise.
++	* sysdeps/x86_64/multiarch/memmove.S (__libc_memmove): Likewise.
++	* sysdeps/x86_64/multiarch/memmove_chk.S (__memmove_chk):
++	Likewise.
++	* sysdeps/x86_64/multiarch/mempcpy.S (__mempcpy): Likewise.
++	* sysdeps/x86_64/multiarch/mempcpy_chk.S (__mempcpy_chk):
++	Likewise.
++	* sysdeps/x86_64/multiarch/memset.S (memset): Likewise.
++	* sysdeps/x86_64/multiarch/memset_chk.S (__memset_chk):
++	Likewise.
++
++2017-04-28  H.J. Lu  <hongjiu.lu@intel.com>
++
++	* sysdeps/x86/cpu-features.c (init_cpu_features): Set
++	Prefer_No_VZEROUPPER if AVX512ER is available.
++	* sysdeps/x86/cpu-features.h
++	(bit_cpu_AVX512PF): New.
++	(bit_cpu_AVX512ER): Likewise.
++	(bit_cpu_AVX512CD): Likewise.
++	(bit_cpu_AVX512BW): Likewise.
++	(bit_cpu_AVX512VL): Likewise.
++	(index_cpu_AVX512PF): Likewise.
++	(index_cpu_AVX512ER): Likewise.
++	(index_cpu_AVX512CD): Likewise.
++	(index_cpu_AVX512BW): Likewise.
++	(index_cpu_AVX512VL): Likewise.
++	(reg_AVX512PF): Likewise.
++	(reg_AVX512ER): Likewise.
++	(reg_AVX512CD): Likewise.
++	(reg_AVX512BW): Likewise.
++	(reg_AVX512VL): Likewise.
++
++2017-01-05  Joseph Myers  <joseph@codesourcery.com>
++
++	[BZ #21026]
++	* sysdeps/unix/sysv/linux/mips/mips64/n64/syscalls.list
++	(readahead): New syscall entry.
++
++2017-04-07  H.J. Lu  <hongjiu.lu@intel.com>
++
++	[BZ #21258]
++	* sysdeps/x86_64/dl-trampoline.S (_dl_runtime_resolve_opt):
++	Define only if _dl_runtime_resolve is defined to
++	_dl_runtime_resolve_sse_vex.
++	* sysdeps/x86_64/dl-trampoline.h (_dl_runtime_resolve_opt):
++	Fallthrough to _dl_runtime_resolve_sse_vex.
++
++2017-04-03  Mike Frysinger  <vapier@gentoo.org>
++
++	[BZ #21253]
++	* sysdeps/unix/sysv/linux/spawni.c (__spawnix): Increase argv_size
++	slack space by 32KiB.
++
++2017-03-31  Slava Barinov  <v.barinov@samsung.com>
++
++	[BZ #21289]
++	* io/fts.h (fts_set): Replace __REDIRECT with __REDIRECT_NTH.
++
++2017-03-20  Mike Frysinger  <vapier@gentoo.org>
++
++	[BZ #21275]
++	* sysdeps/unix/sysv/linux/spawni.c [__ia64__] (CLONE): Rename
++	__stack to __stackbase.
++	(STACK): Invert _STACK_GROWS_DOWN and _STACK_GROWS_UP order of
++	checks so we can include defined(__ia64__) first.
++
++2017-03-15  John David Anglin  <danglin@gcc.gnu.org>
++
++	* sysdeps/hppa/dl-machine.h (DL_STACK_END): Define.
++	(RTLD_START): Don't record stack end address in _dl_start_user.
++
++2017-01-30  H.J. Lu  <hongjiu.lu@intel.com>
++
++	[BZ #21081]
++	* sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S
++	(L(stosb)): Add VZEROUPPER before ret.
++
++2016-11-28  H.J. Lu  <hongjiu.lu@intel.com>
++
++	[BZ #20750]
++	* sysdeps/x86_64/sysdep.h (JUMPTARGET): Check SHARED instead
++	of PIC.
++
++2016-12-31  Florian Weimer  <fweimer@redhat.com>
++
++	[BZ #18784]
++	CVE-2015-5180
++	* include/arpa/nameser_compat.h (T_QUERY_A_AND_AAAA): Rename from
++	T_UNSPEC.  Adjust value.
++	* resolv/nss_dns/dns-host.c (_nss_dns_gethostbyname4_r): Use it.
++	* resolv/res_query.c (__libc_res_nquery): Likewise.
++	* resolv/res_mkquery.c (res_nmkquery): Check for out-of-range
++	QTYPEs.
++	* resolv/tst-resolv-qtypes.c: New file.
++	* resolv/Makefile (xtests): Add tst-resolv-qtypes.
++	(tst-resolv-qtypes): Link against libresolv and libpthread.
++
++2017-02-02  Siddhesh Poyarekar  <siddhesh@sourceware.org>
++
++	* sysdeps/generic/unsecvars.h: Add GLIBC_TUNABLES.
++
++2017-01-23  Rajalakshmi Srinivasaraghavan  <raji@linux.vnet.ibm.com>
++	    Steven Munroe  <sjmunroe@us.ibm.com>
++	    Tulio Magno Quites Machado Filho  <tuliom@linux.vnet.ibm.com>
++
++	[BZ #20822]
++	* sysdeps/unix/sysv/linux/powerpc/elision-lock.c
++	(__lll_lock_elision): Access adapt_count via C11 atomics.
++	* sysdeps/unix/sysv/linux/powerpc/elision-trylock.c
++	(__lll_trylock_elision): Likewise.
++	* sysdeps/unix/sysv/linux/powerpc/elision-unlock.c
++	(__lll_unlock_elision):  Update adapt_count variable inside the
++	critical section using C11 atomics.
++
++2016-12-24  Carlos O'Donell  <carlos@redhat.com>
++
++	[BZ #11941]
++	* elf/dl-close.c (_dl_close): Take dl_load_lock to examine map.
++	Remove assert (map->l_init_called); if DF_1_NODELETE is set.
++	* elf/Makefile [ifeq (yes,$(build-shared))] (tests): Add
++	tst-nodelete-dlclose.
++	(modules-names): Add tst-nodelete-dlclose-dso and
++	tst-nodelete-dlclose-plugin.
++	($(objpfx)tst-nodelete-dlclose-dso.so): Define.
++	($(objpfx)tst-nodelete-dlclose-plugin.so): Define.
++	($(objpfx)tst-nodelete-dlclose): Define.
++	($(objpfx)tst-nodelete-dlclose.out): Define.
++
++2016-08-02  Aurelien Jarno  <aurelien@aurel32.net>
++
++2016-08-02  Aurelien Jarno  <aurelien@aurel32.net>
++
++	* sysdeps/alpha/fpu/s_ceil.c (__ceil): Add argument with itself
++	when it is a NaN.
++	[_IEEE_FP_INEXACT] Remove.
++	* sysdeps/alpha/fpu/s_ceilf.c (__ceilf): Likewise.
++	* sysdeps/alpha/fpu/s_floor.c (__floor): Add argument with itself
++	when it is a NaN.
++	[_IEEE_FP_INEXACT] Remove.
++	* sysdeps/alpha/fpu/s_floorf.c (__floorf): Likewise.
++	* sysdeps/alpha/fpu/s_rint.c (__rint): Add argument with itself
++	when it is a NaN.
++	* sysdeps/alpha/fpu/s_rintf.c (__rintf): Likewise.
++	* sysdeps/alpha/fpu/s_trunc.c (__trunc): Return the input value
++	when its absolute value is greater than 0x1.0p52.
++	[_IEEE_FP_INEXACT] Remove.
++	* sysdeps/alpha/fpu/s_truncf.c (__truncf): Return the input value
++	when its absolute value is greater than 0x1.0p23.
++	[_IEEE_FP_INEXACT] Remove.
++
++2016-11-30  H.J. Lu  <hongjiu.lu@intel.com>
++
++	[BZ #20495]
++	[BZ #20508]
++	* sysdeps/x86/cpu-features.c (init_cpu_features): For Intel
++	processors, set Use_dl_runtime_resolve_slow and set
++	Use_dl_runtime_resolve_opt if XGETBV suports ECX == 1.
++	* sysdeps/x86/cpu-features.h (bit_arch_Use_dl_runtime_resolve_opt):
++	New.
++	(bit_arch_Use_dl_runtime_resolve_slow): Likewise.
++	(index_arch_Use_dl_runtime_resolve_opt): Likewise.
++	(index_arch_Use_dl_runtime_resolve_slow): Likewise.
++	* sysdeps/x86_64/dl-machine.h (elf_machine_runtime_setup): Use
++	_dl_runtime_resolve_avx512_opt and _dl_runtime_resolve_avx_opt
++	if Use_dl_runtime_resolve_opt is set.  Use
++	_dl_runtime_resolve_slow if Use_dl_runtime_resolve_slow is set.
++	* sysdeps/x86_64/dl-trampoline.S: Include <cpu-features.h>.
++	(_dl_runtime_resolve_opt): New.  Defined for AVX and AVX512.
++	(_dl_runtime_resolve): Add one for _dl_runtime_resolve_sse_vex.
++	* sysdeps/x86_64/dl-trampoline.h (_dl_runtime_resolve_avx_slow):
++	New.
++	(_dl_runtime_resolve_opt): Likewise.
++	(_dl_runtime_profile): Define only if _dl_runtime_profile is
++	defined.
++
++2016-11-24  Aurelien Jarno  <aurelien@aurel32.net>
++
++	* sysdeps/x86_64/memcpy_chk.S (__memcpy_chk): Check for SHARED
++	instead of PIC.
++
++2016-11-23  Matthew Fortune  <Matthew.Fortune@imgtec.com>
++	    Maciej W. Rozycki  <macro@imgtec.com>
++
++	* sysdeps/mips/mips32/crti.S (_init): Add `.insn' pseudo-op at
++	`.Lno_weak_fn' label.
++	* sysdeps/mips/mips64/n32/crti.S (_init): Likewise.
++	* sysdeps/mips/mips64/n64/crti.S (_init): Likewise.
++
++2016-11-22  Adhemerval Zanella  <adhemerva.zanella@linaro.org>
++
++	[BZ #20847]
++	* posix/execvpe.c (maybe_script_execute): Remove write past allocated
++	array bounds.
++	(__execvpe): Likewise.
++
++2016-11-15  Denis Kaganovich  <mahatma@eu.by>
++	    Magnus Granberg  <zorry@gentoo.org>
++	    Mike Frysinger  <vapier@gentoo.org>
++
++	[BZ #20662]
++	* configure.ac (libc_cv_predef_stack_protector): Also check for
++	__stack_chk_fail_local symbols.
++	* configure: Regenerated.
++
++2016-11-03  Joseph Myers  <joseph@codesourcery.com>
++
++	* conform/Makefile ($(linknamespace-header-tests)): Also depend on
++	$(linknamespace-symlists-tests).
++
++2016-11-06  Aurelien Jarno  <aurelien@aurel32.net>
++
++	* iconv/gconv.h (__gconv_info): Define __data element using a
++	zero-length array.
++
++2016-10-25  Joseph Myers  <joseph@codesourcery.com>
++
++	* sysdeps/powerpc/powerpc32/power6/memset.S (memset): Use cmplwi
++	instead of cmpli.
++	* sysdeps/powerpc/powerpc64/power6/memset.S (memset): Use cmpldi
++	instead of cmpli.
++
++2016-10-24  Adhemerval Zanella  <adhemerval.zanella@linaro.org>
++
++	* sysdeps/unix/sysv/linux/pread.c (__libc_pread): Use SYSCALL_LL_PRW.
++	* sysdeps/unix/sysv/linux/pwrite.c (__libc_pwrite): Likewise.
++	* sysdeps/unix/sysv/linux/pread64.c (__libc_pread64): Use
++	SYSCALL_LL64_PRW.
++	* sysdeps/unix/sysv/linux/pwrite64.c (__libc_pwrite64): Likewise.
++	* sysdeps/unix/sysv/linux/sh/kernel-features.h: Define
++	__ASSUME_PRW_DUMMY_ARG.
++	* sysdeps/unix/sysv/linux/sh/pread.c: Remove file.
++	* sysdeps/unix/sysv/linux/sh/pread64.c: Likewise.
++	* sysdeps/unix/sysv/linux/sh/pwrite.c: Likewise.
++	* sysdeps/unix/sysv/linux/sh/pwrite64.c: Likewise.
++	* sysdeps/unix/sysv/linux/sysdep.h: Define SYSCALL_LL_PRW and
++	SYSCALL_LL_PRW64 based on __ASSUME_PRW_DUMMY_ARG.
++
++2016-10-05  Tulio Magno Quites Machado Filho  <tuliom@linux.vnet.ibm.com>
++
++	* sysdeps/powerpc/fpu/libm-test-ulps: Regenerated.
++
++2016-09-20  Adhemerval Zanella  <adhemerval.zanella@linaro.org>
++
++	* sysdeps/unix/sysv/linux/spawni.c (__spawnix): Correctly block and unblock
++	all signals when executing the clone vfork child.
++	(SIGALL_SET): Remove macro.
++
++	* nptl/Makefile (tests): Add tst-exec5.
++	* nptl/tst-exec5.c: New file.
++	* sysdeps/unix/sysv/linux/spawni.c (__spawni): Correctly enable and disable
++	asynchronous cancellation.
++
++2016-09-19  Tulio Magno Quites Machado Filho  <tuliom@linux.vnet.ibm.com>
++
++	[BZ #20615]
++	* sysdeps/powerpc/powerpc32/power9/multiarch/Implies: Replace
++	fpu directory by non-fpu.
++	* sysdeps/powerpc/powerpc64/power9/fpu/Implies: Remove dependency
++	on non-fpu directory from a fpu directory.
++
++2016-09-02  Roland McGrath  <roland@hack.frob.com>
++
++	* sysdeps/arm/nacl/libc.abilist: Add GLIBC_2.24 A.
++
++	* sysdeps/nacl/dup.c: Add libc_hidden_def.
++
++2016-09-02  Roland McGrath  <roland@hack.frob.com>
++
++	* sysdeps/posix/wait3.c: Don't treat STAT_LOC as a union, since it's
++	not any more.
++
++2016-09-02  Roland McGrath  <roland@hack.frob.com>
++
++	* sysdeps/nacl/clock.c (clock): nacl_abi_clock_t -> nacl_irt_clock_t
++
++2016-08-17  Florian Weimer  <fweimer@redhat.com>
++
++	Reduce time to expected nptl/tst-once5 failure.
++	* nptl/tst-once5.cc (TIMEOUT): Define.
++
++2016-08-18  Florian Weimer  <fweimer@redhat.com>
++
++	[BZ #16907]
++	* argp/argp.h: Switch to __BEGIN_DECLS and __END_DECLS.
++	(__THROW, __NTH, __attribute__, __restrict): Remove definitions.
++	* argp/argp-fmtstream.h: Add __BEGIN_DECLS and __END_DECLS.
++	(__attribute__): Remove definition.
++
++2016-08-15  Andreas Schwab  <schwab@suse.de>
++
++	[BZ #20435]
++	* sysdeps/unix/sysv/linux/arm/setcontext.S (__startcontext): Mark
++	as .cantunwind.
++
++2016-08-17  Florian Weimer  <fweimer@redhat.com>
++
++	[BZ #20452]
++	Avoid additional copies of objects in libc.a in static libraries.
++	* sysdeps/ia64/nptl/Makefile (libpthread-shared-only-routines):
++	Add ptw-sysdep, ptw-sigblock, ptw-sigprocmask.
++	* sysdeps/mips/Makefile (librt-shared-only-routines): Add
++	rt-sysdep.
++	* sysdeps/mips/nptl/Makefile (libpthread-shared-only-routines):
++	Add nptl-sysdep.
++	* sysdeps/s390/nptl/Makefile (libpthread-shared-only-routines):
++	Add ptw-sysdep.
++	* sysdeps/unix/alpha/Makefile (librt-shared-only-routines): Add
++	rt-sysdep.
++	* sysdeps/unix/sysv/linux/alpha/Makefile
++	(libpthread-shared-only-routines): Add ptw-sysdep,
++	ptw-sigprocmask, ptw-rt_sigaction.
++	* sysdeps/unix/sysv/linux/ia64/Makefile
++	(librt-shared-only-routines): Add rt-sysdep.
++	* sysdeps/unix/sysv/linux/i386/Makefile
++	(libpthread-shared-only-routines): Add libc-do-syscall.
++	* sysdeps/unix/sysv/linux/microblaze/Makefile
++	(libpthread-shared-only-routines): Add sysdep.
++	* sysdeps/unix/sysv/linux/powerpc/Makefile
++	(librt-shared-only-routines): Add rt-sysdep.
++	(libpthread-shared-only-routines): Add sysdep.
++	* sysdeps/unix/sysv/linux/s390/Makefile
++	(librt-shared-only-routines): Add rt-sysdep.
++	* sysdeps/unix/sysv/linux/sparc/Makefile
++	(librt-shared-only-routines): Add rt-sysdep.
++	(libpthread-shared-only-routines): Add sysdep.
++	* sysdeps/unix/sysv/linux/tile/Makefile
++	(libpthread-shared-only-routines): Likewise.
++
++2016-08-05  Aurelien Jarno  <aurelien@aurel32.net>
++
++	* sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/Makefile
++	[$(subdir) = math && $(have-as-vis3) = yes] (libm-sysdep_routines):
++	Remove s_fdimf-vis3, s_fdim-vis3.
++	* sysdeps/sparc/sparc32/fpu/s_fdim.S: Delete file.
++	* sysdeps/sparc/sparc32/fpu/s_fdimf.S: Likewise.
++	* sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdim-vis3.S: Likewise.
++	* sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdim.S: Likewise.
++	* sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdimf-vis3.S: Likewise.
++	* sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdimf.S: Likewise.
++	* sysdeps/sparc/sparc32/sparcv9/fpu/s_fdim.S: Likewise.
++	* sysdeps/sparc/sparc32/sparcv9/fpu/s_fdimf.S: Likewise.
++	* sysdeps/sparc/sparc64/fpu/s_fdim.S: Likewise.
++	* sysdeps/sparc/sparc64/fpu/s_fdimf.S: Likewise.
++
++2016-08-02  David S. Miller  <davem@davemloft.net>
++
++	* sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_nearbyint-vis3.S
++	(__nearbyint_vis3): Don't check for sNaN before float register is
++	loaded with the incoming argument.
++	* sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_nearbyintf-vis3.S
++	(__nearbyintf_vis3): Likewise.
++	* sysdeps/sparc/sparc32/sparcv9/fpu/s_nearbyint.S (__nearbyint):
++	Likewise.
++	* sysdeps/sparc/sparc32/sparcv9/fpu/s_nearbyintf.S (__nearbyintf):
++	Likewise.
++
++2016-08-03  Aurelien Jarno  <aurelien@aurel32.net>
++
++	* sysdeps/powerpc/ifunc-sel.h (ifunc_sel): Replace beqlr instructions
++	by beq instructions jumping to the end of the function.
++	* sysdeps/powerpc/ifunc-sel.h (ifunc_sel): Add "11", "12", "cr0" to the
++	clobber list. Use "i" constraint instead of "X".
++	(ifunc_one): Add "12" to the clobber list. Use "i" constraint instead
++	of "X".
++
++2016-08-04  Carlos O'Donell  <carlos@redhat.com>
++
++	* po/de.po: Update from Translation Project.
++	* po/fi.po: Likewise.
++	* po/sv.po: Likewise.
++
++2016-08-02  Florian Weimer  <fweimer@redhat.com>
++
++	[BZ #20370]
++	* malloc/arena.c (get_free_list): Update comment.  Assert that
++	arenas on the free list have no attached threads.
++	(remove_from_free_list): New function.
++	(reused_arena): Call it.
++
++2016-08-04  Florian Weimer  <fweimer@redhat.com>
++
++	Use sysdep.o from libc.a in static libraries.
++	* sysdeps/unix/sysv/linux/i386/Makefile
++	(libpthread-shared-only-routines): Add sysdep.
++	(librt-shared-only-routines): Likewise.
++
+ 2016-08-01  Carlos O'Donell  <carlos@redhat.com>
+ 
+ 	* version.h (RELEASE): Set to "stable"
+diff --git a/Makeconfig b/Makeconfig
+index 03fd89c13e..ee379f5852 100644
+--- a/Makeconfig
++++ b/Makeconfig
+@@ -394,6 +394,9 @@ ifndef after-link
+ after-link =
+ endif
+ 
++# Additional libraries to link into every test.
++link-extra-libs-tests = $(libsupport)
++
+ # Command for linking PIE programs with the C library.
+ ifndef +link-pie
+ +link-pie-before-libc = $(CC) -pie -Wl,-O1 -nostdlib -nostartfiles -o $@ \
+@@ -503,7 +506,7 @@ link-libc = $(link-libc-rpath-link) $(link-libc-before-gnulib) $(gnulib)
+ link-libc-tests = $(link-libc-tests-rpath-link) \
+ 		  $(link-libc-before-gnulib) $(gnulib-tests)
+ # 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-dirs = math elf dlfcn nss nis rt resolv crypt mathvec support
+ rpath-link = \
+ $(common-objdir):$(subst $(empty) ,:,$(patsubst ../$(subdir),.,$(rpath-dirs:%=$(common-objpfx)%)))
+ else
+@@ -850,7 +853,7 @@ libio-include = -I$(..)libio
+ # List of non-library modules that we build.
+ built-modules = iconvprogs iconvdata ldconfig lddlibc4 libmemusage \
+ 		libSegFault libpcprofile librpcsvc locale-programs \
+-		memusagestat nonlib nscd extramodules libnldbl
++		memusagestat nonlib nscd extramodules libnldbl libsupport
+ 
+ in-module = $(subst -,_,$(firstword $(libof-$(basename $(@F))) \
+ 				    $(libof-$(<F)) \
+@@ -1089,6 +1092,12 @@ libm = $(common-objpfx)math/libm.a
+ libmvec = $(common-objpfx)mathvec/libmvec.a
+ endif
+ 
++ifeq ($(build-shared),yes)
++libsupport = $(common-objpfx)support/libsupport_nonshared.a
++else
++libsupport = $(common-objpfx)support/libsupport.a
++endif
++
+ # These are the subdirectories containing the library source.  The order
+ # is more or less arbitrary.  The sorting step will take care of the
+ # dependencies.
+@@ -1096,7 +1105,7 @@ all-subdirs = csu assert ctype locale intl catgets math setjmp signal	    \
+ 	      stdlib stdio-common libio malloc string wcsmbs time dirent    \
+ 	      grp pwd posix io termios resource misc socket sysvipc gmon    \
+ 	      gnulib iconv iconvdata wctype manual shadow gshadow po argp   \
+-	      crypt localedata timezone rt conform debug mathvec	    \
++	      crypt localedata timezone rt conform debug mathvec support    \
+ 	      $(add-on-subdirs) dlfcn elf
+ 
+ ifndef avoid-generated
+diff --git a/NEWS b/NEWS
+index b0447e7169..20e30028cf 100644
+--- a/NEWS
++++ b/NEWS
+@@ -5,6 +5,68 @@ See the end for copying conditions.
+ Please send GNU C library bug reports via <http://sourceware.org/bugzilla/>
+ using `glibc' in the "product" field.
+ 
++Version 2.24.1
++
++Security related changes:
++
++* On ARM EABI (32-bit), generating a backtrace for execution contexts which
++  have been created with makecontext could fail to terminate due to a
++  missing .cantunwind annotation.  This has been observed to lead to a hang
++  (denial of service) in some Go applications compiled with gccgo.  Reported
++  by Andreas Schwab.  (CVE-2016-6323)
++
++* The DNS stub resolver functions would crash due to a NULL pointer
++  dereference when processing a query with a valid DNS question type which
++  was used internally in the implementation.  The stub resolver now uses a
++  question type which is outside the range of valid question type values.
++  (CVE-2015-5180)
++
++* CVE-2017-15670: The glob function, when invoked with GLOB_TILDE, suffered
++  from a one-byte overflow during ~ operator processing (either on the stack
++  or the heap, depending on the length of the user name).
++
++* CVE-2017-15671: The glob function, when invoked with GLOB_TILDE,
++  would sometimes fail to free memory allocated during ~ operator
++  processing, leading to a memory leak and, potentially, to a denial
++  of service.
++
++* CVE-2017-15804: The glob function, when invoked with GLOB_TILDE and
++  without GLOB_NOESCAPE, could write past the end of a buffer while
++  unescaping user names.  Reported by Tim Rühsen.
++
++* CVE-2017-1000408: Incorrect array size computation in _dl_init_paths leads
++  to the allocation of too much memory.  (This is not a security bug per se,
++  it is mentioned here only because of the CVE assignment.)  Reported by
++  Qualys.
++
++* CVE-2017-1000409: Buffer overflow in _dl_init_paths due to miscomputation
++  of the number of search path components.  (This is not a security
++  vulnerability per se because no trust boundary is crossed if the fix for
++  CVE-2017-1000366 has been applied, but it is mentioned here only because
++  of the CVE assignment.)  Reported by Qualys.
++
++  CVE-2017-16997: Incorrect handling of RPATH or RUNPATH containing $ORIGIN
++  for AT_SECURE or SUID binaries could be used to load libraries from the
++  current directory.
++
++  CVE-2018-1000001: Buffer underflow in realpath function when getcwd function
++  succeeds without returning an absolute path due to unexpected behaviour
++  of the Linux kernel getcwd syscall.  Reported by halfdog.
++
++The following bugs are resolved with this release:
++
++  [20790] Fix rpcgen buffer overrun
++  [20978] Fix strlen on null pointer in nss_nisplus
++  [21209] Ignore and remove LD_HWCAP_MASK for AT_SECURE programs
++  [21265] x86-64: Use fxsave/xsave/xsavec in _dl_runtime_resolve
++  [21289] Fix symbol redirect for fts_set
++  [21386] Assertion in fork for distinct parent PID is incorrect
++  [21609] x86-64: Align the stack in __tls_get_addr
++  [21624] Unsafe alloca allows local attackers to alias stack and heap (CVE-2017-1000366)
++  [21654] nss: Fix invalid cast in group merging
++  [22679] getcwd(3) can succeed without returning an absolute path
++    (CVE-2018-1000001)
++
+ Version 2.24
+ 
+ * The minimum Linux kernel version that this version of the GNU C Library
+diff --git a/Rules b/Rules
+index 8306d36a07..a981965d2b 100644
+--- a/Rules
++++ b/Rules
+@@ -149,6 +149,7 @@ endif
+ 
+ ifneq "$(strip $(binaries-shared-tests))" ""
+ $(addprefix $(objpfx),$(binaries-shared-tests)): %: %.o \
++  $(link-extra-libs-tests) \
+   $(sort $(filter $(common-objpfx)lib%,$(link-libc))) \
+   $(addprefix $(csu-objpfx),start.o) $(+preinit) $(+postinit)
+ 	$(+link-tests)
+@@ -156,6 +157,7 @@ endif
+ 
+ ifneq "$(strip $(binaries-pie-tests))" ""
+ $(addprefix $(objpfx),$(binaries-pie-tests)): %: %.o \
++  $(link-extra-libs-tests) \
+   $(sort $(filter $(common-objpfx)lib%,$(link-libc))) \
+   $(addprefix $(csu-objpfx),start.o) $(+preinit) $(+postinit)
+ 	$(+link-pie-tests)
+@@ -177,6 +179,7 @@ endif
+ 
+ ifneq "$(strip $(binaries-static-tests))" ""
+ $(addprefix $(objpfx),$(binaries-static-tests)): %: %.o \
++  $(link-extra-libs-tests) \
+   $(sort $(filter $(common-objpfx)lib%,$(link-libc-static-tests))) \
+   $(addprefix $(csu-objpfx),start.o) $(+preinit) $(+postinit)
+ 	$(+link-static-tests)
+diff --git a/argp/argp-fmtstream.h b/argp/argp-fmtstream.h
+index bdeaa54dc2..e8c5797f38 100644
+--- a/argp/argp-fmtstream.h
++++ b/argp/argp-fmtstream.h
+@@ -29,21 +29,6 @@
+ #include <string.h>
+ #include <unistd.h>
+ 
+-#ifndef __attribute__
+-/* This feature is available in gcc versions 2.5 and later.  */
+-# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || \
+-  defined __STRICT_ANSI__
+-#  define __attribute__(Spec) /* empty */
+-# endif
+-/* The __-protected variants of `format' and `printf' attributes
+-   are accepted by gcc versions 2.6.4 (effectively 2.7) and later.  */
+-# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7) || \
+-  defined __STRICT_ANSI__
+-#  define __format__ format
+-#  define __printf__ printf
+-# endif
+-#endif
+-
+ #if defined (__GNU_LIBRARY__) && defined (HAVE_LINEWRAP_H)
+ /* line_wrap_stream is available, so use that.  */
+ #define ARGP_FMTSTREAM_USE_LINEWRAP
+@@ -111,6 +96,8 @@ struct argp_fmtstream
+ 
+ typedef struct argp_fmtstream *argp_fmtstream_t;
+ 
++__BEGIN_DECLS
++
+ /* Return an argp_fmtstream that outputs to STREAM, and which prefixes lines
+    written on it with LMARGIN spaces and limits them to RMARGIN columns
+    total.  If WMARGIN >= 0, words that extend past RMARGIN are wrapped by
+@@ -297,6 +284,8 @@ __argp_fmtstream_point (argp_fmtstream_t __fs)
+ 
+ #endif /* __OPTIMIZE__ */
+ 
++__END_DECLS
++
+ #endif /* ARGP_FMTSTREAM_USE_LINEWRAP */
+ 
+ #endif /* argp-fmtstream.h */
+diff --git a/argp/argp.h b/argp/argp.h
+index e67bbef739..7cb5a69f08 100644
+--- a/argp/argp.h
++++ b/argp/argp.h
+@@ -28,48 +28,12 @@
+ #define __need_error_t
+ #include <errno.h>
+ 
+-#ifndef __THROW
+-# define __THROW
+-#endif
+-#ifndef __NTH
+-# define __NTH(fct) fct __THROW
+-#endif
+-
+-#ifndef __attribute__
+-/* This feature is available in gcc versions 2.5 and later.  */
+-# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || \
+-  defined __STRICT_ANSI__
+-#  define __attribute__(Spec) /* empty */
+-# endif
+-/* The __-protected variants of `format' and `printf' attributes
+-   are accepted by gcc versions 2.6.4 (effectively 2.7) and later.  */
+-# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7) || \
+-  defined __STRICT_ANSI__
+-#  define __format__ format
+-#  define __printf__ printf
+-# endif
+-#endif
+-
+-/* GCC 2.95 and later have "__restrict"; C99 compilers have
+-   "restrict", and "configure" may have defined "restrict".  */
+-#ifndef __restrict
+-# if ! (2 < __GNUC__ || (2 == __GNUC__ && 95 <= __GNUC_MINOR__))
+-#  if defined restrict || 199901L <= __STDC_VERSION__
+-#   define __restrict restrict
+-#  else
+-#   define __restrict
+-#  endif
+-# endif
+-#endif
+-
+ #ifndef __error_t_defined
+ typedef int error_t;
+ # define __error_t_defined
+ #endif
+ 
+-#ifdef  __cplusplus
+-extern "C" {
+-#endif
++__BEGIN_DECLS
+ 
+ /* A description of a particular option.  A pointer to an array of
+    these is passed in the OPTIONS field of an argp structure.  Each option
+@@ -590,8 +554,6 @@ __NTH (__option_is_end (const struct argp_option *__opt))
+ # endif
+ #endif /* Use extern inlines.  */
+ 
+-#ifdef  __cplusplus
+-}
+-#endif
++__END_DECLS
+ 
+ #endif /* argp.h */
+diff --git a/configure b/configure
+index 17625e1041..9b5a486048 100755
+--- a/configure
++++ b/configure
+@@ -6289,12 +6289,14 @@ echo >&5 "libc_undefs='$libc_undefs'"
+ # symbols (resolved by the linker), so filter out unknown symbols.
+ # This will fail to produce the correct result if the compiler
+ # defaults to -fstack-protector but this produces an undefined symbol
+-# other than __stack_chk_fail.  However, compilers like that have not
+-# been encountered in practice.
+-libc_undefs=`echo "$libc_undefs" | egrep '^(foobar|__stack_chk_fail)$'`
++# other than __stack_chk_fail or __stack_chk_fail_local. However,
++# compilers like that have not been encountered in practice.
++libc_undefs=`echo "$libc_undefs" | \
++  egrep '^(foobar|__stack_chk_fail|__stack_chk_fail_local)$'`
+ case "$libc_undefs" in
+ foobar) libc_cv_predef_stack_protector=no ;;
+ '__stack_chk_fail
++foobar'|'__stack_chk_fail_local
+ foobar') libc_cv_predef_stack_protector=yes ;;
+ *) as_fn_error $? "unexpected symbols in test: $libc_undefs" "$LINENO" 5 ;;
+ esac
+diff --git a/configure.ac b/configure.ac
+index 33bcd62180..8277d9f727 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -1626,12 +1626,14 @@ echo >&AS_MESSAGE_LOG_FD "libc_undefs='$libc_undefs'"
+ # symbols (resolved by the linker), so filter out unknown symbols.
+ # This will fail to produce the correct result if the compiler
+ # defaults to -fstack-protector but this produces an undefined symbol
+-# other than __stack_chk_fail.  However, compilers like that have not
+-# been encountered in practice.
+-libc_undefs=`echo "$libc_undefs" | egrep '^(foobar|__stack_chk_fail)$'`
++# other than __stack_chk_fail or __stack_chk_fail_local. However,
++# compilers like that have not been encountered in practice.
++libc_undefs=`echo "$libc_undefs" | \
++  egrep '^(foobar|__stack_chk_fail|__stack_chk_fail_local)$'`
+ case "$libc_undefs" in
+ foobar) libc_cv_predef_stack_protector=no ;;
+ '__stack_chk_fail
++foobar'|'__stack_chk_fail_local
+ foobar') libc_cv_predef_stack_protector=yes ;;
+ *) AC_MSG_ERROR([unexpected symbols in test: $libc_undefs]) ;;
+ esac],
+diff --git a/conform/Makefile b/conform/Makefile
+index 32a0937b06..7883624c81 100644
+--- a/conform/Makefile
++++ b/conform/Makefile
+@@ -196,13 +196,13 @@ $(conformtest-header-tests): $(objpfx)%/conform.out: \
+ 			     conformtest.pl $(conformtest-headers-data)
+ 	(set -e; std_hdr=$*; std=$${std_hdr%%/*}; hdr=$${std_hdr#*/}; \
+ 	 mkdir -p $(@D)/scratch; \
+-	 $(PERL) conformtest.pl --tmpdir=$(@D)/scratch --cc='$(CC)' \
++	 $(PERL) -I. conformtest.pl --tmpdir=$(@D)/scratch --cc='$(CC)' \
+ 		 --flags='$(conformtest-cc-flags)' --standard=$$std \
+ 		 --headers=$$hdr > $@); \
+ 	$(evaluate-test)
+ 
+ $(linknamespace-symlists-tests): $(objpfx)symlist-%: list-header-symbols.pl
+-	$(PERL) -w $< --tmpdir=$(objpfx) --cc='$(CC)' \
++	$(PERL) -I. -w $< --tmpdir=$(objpfx) --cc='$(CC)' \
+ 		--flags='$(conformtest-cc-flags)' --standard=$* \
+ 		--headers="$(strip $(conformtest-headers-$*))" \
+ 		> $@ 2> $@.err; \
+@@ -229,10 +229,11 @@ $(linknamespace-symlist-stdlibs-tests): $(objpfx)symlist-stdlibs-%: \
+ 
+ $(linknamespace-header-tests): $(objpfx)%/linknamespace.out: \
+ 			       linknamespace.pl \
++			       $(linknamespace-symlists-tests) \
+ 			       $(linknamespace-symlist-stdlibs-tests)
+ 	(set -e; std_hdr=$*; std=$${std_hdr%%/*}; hdr=$${std_hdr#*/}; \
+ 	 mkdir -p $(@D)/scratch; \
+-	 $(PERL) -w $< --tmpdir=$(@D)/scratch --cc='$(CC)' \
++	 $(PERL) -I. -w $< --tmpdir=$(@D)/scratch --cc='$(CC)' \
+ 		 --flags='$(conformtest-cc-flags)' --standard=$$std \
+ 		 --stdsyms=$(objpfx)symlist-$$std --header=$$hdr \
+ 		 --libsyms=$(objpfx)symlist-stdlibs-$$std \
+diff --git a/elf/Makefile b/elf/Makefile
+index 593403c640..847a012f84 100644
+--- a/elf/Makefile
++++ b/elf/Makefile
+@@ -149,7 +149,8 @@ tests += loadtest restest1 preloadtest loadfail multiload origtest resolvfail \
+ 	 tst-nodelete) \
+ 	 tst-initorder tst-initorder2 tst-relsort1 tst-null-argv \
+ 	 tst-ptrguard1 tst-tlsalign tst-tlsalign-extern tst-nodelete-opened \
+-	 tst-nodelete2 tst-audit11 tst-audit12 tst-dlsym-error
++	 tst-nodelete2 tst-audit11 tst-audit12 tst-dlsym-error \
++	 tst-nodelete-dlclose
+ #	 reldep9
+ ifeq ($(build-hardcoded-path-in-tests),yes)
+ tests += tst-dlopen-aout
+@@ -223,7 +224,8 @@ modules-names = testobj1 testobj2 testobj3 testobj4 testobj5 testobj6 \
+ 		tst-array5dep tst-null-argv-lib \
+ 		tst-tlsalign-lib tst-nodelete-opened-lib tst-nodelete2mod \
+ 		tst-audit11mod1 tst-audit11mod2 tst-auditmod11 \
+-		tst-audit12mod1 tst-audit12mod2 tst-audit12mod3 tst-auditmod12
++		tst-audit12mod1 tst-audit12mod2 tst-audit12mod3 tst-auditmod12 \
++		tst-nodelete-dlclose-dso tst-nodelete-dlclose-plugin
+ ifeq (yes,$(have-mtls-dialect-gnu2))
+ tests += tst-gnu2-tls1
+ modules-names += tst-gnu2-tls1mod
+@@ -1267,3 +1269,12 @@ $(objpfx)tst-ldconfig-X.out : tst-ldconfig-X.sh $(objpfx)ldconfig
+ 	$(evaluate-test)
+ 
+ $(objpfx)tst-dlsym-error: $(libdl)
++
++# The application depends on the DSO, and the DSO loads the plugin.
++# The plugin also depends on the DSO. This creates the circular
++# dependency via dlopen that we're testing to make sure works.
++$(objpfx)tst-nodelete-dlclose-dso.so: $(libdl)
++$(objpfx)tst-nodelete-dlclose-plugin.so: $(objpfx)tst-nodelete-dlclose-dso.so
++$(objpfx)tst-nodelete-dlclose: $(objpfx)tst-nodelete-dlclose-dso.so
++$(objpfx)tst-nodelete-dlclose.out: $(objpfx)tst-nodelete-dlclose-dso.so \
++				   $(objpfx)tst-nodelete-dlclose-plugin.so
+diff --git a/elf/dl-close.c b/elf/dl-close.c
+index 687d7de874..9f93ab7628 100644
+--- a/elf/dl-close.c
++++ b/elf/dl-close.c
+@@ -805,19 +805,37 @@ _dl_close (void *_map)
+ {
+   struct link_map *map = _map;
+ 
+-  /* First see whether we can remove the object at all.  */
++  /* We must take the lock to examine the contents of map and avoid
++     concurrent dlopens.  */
++  __rtld_lock_lock_recursive (GL(dl_load_lock));
++
++  /* At this point we are guaranteed nobody else is touching the list of
++     loaded maps, but a concurrent dlclose might have freed our map
++     before we took the lock. There is no way to detect this (see below)
++     so we proceed assuming this isn't the case.  First see whether we
++     can remove the object at all.  */
+   if (__glibc_unlikely (map->l_flags_1 & DF_1_NODELETE))
+     {
+-      assert (map->l_init_called);
+       /* Nope.  Do nothing.  */
++      __rtld_lock_unlock_recursive (GL(dl_load_lock));
+       return;
+     }
+ 
++  /* At present this is an unreliable check except in the case where the
++     caller has recursively called dlclose and we are sure the link map
++     has not been freed.  In a non-recursive dlclose the map itself
++     might have been freed and this access is potentially a data race
++     with whatever other use this memory might have now, or worse we
++     might silently corrupt memory if it looks enough like a link map.
++     POSIX has language in dlclose that appears to guarantee that this
++     should be a detectable case and given that dlclose should be threadsafe
++     we need this to be a reliable detection.
++     This is bug 20990. */
+   if (__builtin_expect (map->l_direct_opencount, 1) == 0)
+-    GLRO(dl_signal_error) (0, map->l_name, NULL, N_("shared object not open"));
+-
+-  /* Acquire the lock.  */
+-  __rtld_lock_lock_recursive (GL(dl_load_lock));
++    {
++      __rtld_lock_unlock_recursive (GL(dl_load_lock));
++      _dl_signal_error (0, map->l_name, NULL, N_("shared object not open"));
++    }
+ 
+   _dl_close_worker (map, false);
+ 
+diff --git a/elf/dl-load.c b/elf/dl-load.c
+index c0d6249373..1f774e139f 100644
+--- a/elf/dl-load.c
++++ b/elf/dl-load.c
+@@ -37,6 +37,7 @@
+ #include <sysdep.h>
+ #include <stap-probe.h>
+ #include <libc-internal.h>
++#include <array_length.h>
+ 
+ #include <dl-dst.h>
+ #include <dl-load.h>
+@@ -103,7 +104,9 @@ static size_t ncapstr attribute_relro;
+ static size_t max_capstrlen attribute_relro;
+ 
+ 
+-/* Get the generated information about the trusted directories.  */
++/* Get the generated information about the trusted directories.  Use
++   an array of concatenated strings to avoid relocations.  See
++   gen-trusted-dirs.awk.  */
+ #include "trusted-dirs.h"
+ 
+ static const char system_dirs[] = SYSTEM_DIRS;
+@@ -111,9 +114,7 @@ static const size_t system_dirs_len[] =
+ {
+   SYSTEM_DIRS_LEN
+ };
+-#define nsystem_dirs_len \
+-  (sizeof (system_dirs_len) / sizeof (system_dirs_len[0]))
+-
++#define nsystem_dirs_len array_length (system_dirs_len)
+ 
+ static bool
+ is_trusted_path (const char *path, size_t len)
+@@ -433,31 +434,40 @@ fillin_rpath (char *rpath, struct r_search_path_elem **result, const char *sep,
+ {
+   char *cp;
+   size_t nelems = 0;
+-  char *to_free;
+ 
+   while ((cp = __strsep (&rpath, sep)) != NULL)
+     {
+       struct r_search_path_elem *dirp;
++      char *to_free = NULL;
++      size_t len = 0;
+ 
+-      to_free = cp = expand_dynamic_string_token (l, cp, 1);
++      /* `strsep' can pass an empty string.  */
++      if (*cp != '\0')
++	{
++	  to_free = cp = expand_dynamic_string_token (l, cp, 1);
+ 
+-      size_t len = strlen (cp);
++	  /* expand_dynamic_string_token can return NULL in case of empty
++	     path or memory allocation failure.  */
++	  if (cp == NULL)
++	    continue;
+ 
+-      /* `strsep' can pass an empty string.  This has to be
+-	 interpreted as `use the current directory'. */
+-      if (len == 0)
+-	{
+-	  static const char curwd[] = "./";
+-	  cp = (char *) curwd;
+-	}
++	  /* Compute the length after dynamic string token expansion and
++	     ignore empty paths.  */
++	  len = strlen (cp);
++	  if (len == 0)
++	    {
++	      free (to_free);
++	      continue;
++	    }
+ 
+-      /* Remove trailing slashes (except for "/").  */
+-      while (len > 1 && cp[len - 1] == '/')
+-	--len;
++	  /* Remove trailing slashes (except for "/").  */
++	  while (len > 1 && cp[len - 1] == '/')
++	    --len;
+ 
+-      /* Now add one if there is none so far.  */
+-      if (len > 0 && cp[len - 1] != '/')
+-	cp[len++] = '/';
++	  /* Now add one if there is none so far.  */
++	  if (len > 0 && cp[len - 1] != '/')
++	    cp[len++] = '/';
++	}
+ 
+       /* Make sure we don't use untrusted directories if we run SUID.  */
+       if (__glibc_unlikely (check_trusted) && !is_trusted_path (cp, len))
+@@ -621,6 +631,14 @@ decompose_rpath (struct r_search_path_struct *sps,
+      necessary.  */
+   free (copy);
+ 
++  /* There is no path after expansion.  */
++  if (result[0] == NULL)
++    {
++      free (result);
++      sps->dirs = (struct r_search_path_elem **) -1;
++      return false;
++    }
++
+   sps->dirs = result;
+   /* The caller will change this value if we haven't used a real malloc.  */
+   sps->malloced = 1;
+@@ -688,9 +706,8 @@ _dl_init_paths (const char *llp)
+ 		 + ncapstr * sizeof (enum r_dir_status))
+ 		/ sizeof (struct r_search_path_elem));
+ 
+-  rtld_search_dirs.dirs[0] = (struct r_search_path_elem *)
+-    malloc ((sizeof (system_dirs) / sizeof (system_dirs[0]))
+-	    * round_size * sizeof (struct r_search_path_elem));
++  rtld_search_dirs.dirs[0] = malloc (nsystem_dirs_len * round_size
++				     * sizeof (*rtld_search_dirs.dirs[0]));
+   if (rtld_search_dirs.dirs[0] == NULL)
+     {
+       errstring = N_("cannot create cache for search path");
+@@ -776,37 +793,14 @@ _dl_init_paths (const char *llp)
+ 
+   if (llp != NULL && *llp != '\0')
+     {
+-      size_t nllp;
+-      const char *cp = llp;
+-      char *llp_tmp;
+-
+-#ifdef SHARED
+-      /* Expand DSTs.  */
+-      size_t cnt = DL_DST_COUNT (llp, 1);
+-      if (__glibc_likely (cnt == 0))
+-	llp_tmp = strdupa (llp);
+-      else
+-	{
+-	  /* Determine the length of the substituted string.  */
+-	  size_t total = DL_DST_REQUIRED (l, llp, strlen (llp), cnt);
+-
+-	  /* Allocate the necessary memory.  */
+-	  llp_tmp = (char *) alloca (total + 1);
+-	  llp_tmp = _dl_dst_substitute (l, llp, llp_tmp, 1);
+-	}
+-#else
+-      llp_tmp = strdupa (llp);
+-#endif
++      char *llp_tmp = strdupa (llp);
+ 
+       /* Decompose the LD_LIBRARY_PATH contents.  First determine how many
+ 	 elements it has.  */
+-      nllp = 1;
+-      while (*cp)
+-	{
+-	  if (*cp == ':' || *cp == ';')
+-	    ++nllp;
+-	  ++cp;
+-	}
++      size_t nllp = 1;
++      for (const char *cp = llp_tmp; *cp != '\0'; ++cp)
++	if (*cp == ':' || *cp == ';')
++	  ++nllp;
+ 
+       env_path_list.dirs = (struct r_search_path_elem **)
+ 	malloc ((nllp + 1) * sizeof (struct r_search_path_elem *));
+diff --git a/elf/rtld.c b/elf/rtld.c
+index 647661ca45..8f56d6edd3 100644
+--- a/elf/rtld.c
++++ b/elf/rtld.c
+@@ -99,14 +99,121 @@ uintptr_t __pointer_chk_guard_local
+ strong_alias (__pointer_chk_guard_local, __pointer_chk_guard)
+ #endif
+ 
++/* Length limits for names and paths, to protect the dynamic linker,
++   particularly when __libc_enable_secure is active.  */
++#ifdef NAME_MAX
++# define SECURE_NAME_LIMIT NAME_MAX
++#else
++# define SECURE_NAME_LIMIT 255
++#endif
++#ifdef PATH_MAX
++# define SECURE_PATH_LIMIT PATH_MAX
++#else
++# define SECURE_PATH_LIMIT 1024
++#endif
++
++/* Check that AT_SECURE=0, or that the passed name does not contain
++   directories and is not overly long.  Reject empty names
++   unconditionally.  */
++static bool
++dso_name_valid_for_suid (const char *p)
++{
++  if (__glibc_unlikely (__libc_enable_secure))
++    {
++      /* Ignore pathnames with directories for AT_SECURE=1
++	 programs, and also skip overlong names.  */
++      size_t len = strlen (p);
++      if (len >= SECURE_NAME_LIMIT || memchr (p, '/', len) != NULL)
++	return false;
++    }
++  return *p != '\0';
++}
+ 
+-/* List of auditing DSOs.  */
++/* LD_AUDIT variable contents.  Must be processed before the
++   audit_list below.  */
++const char *audit_list_string;
++
++/* Cyclic list of auditing DSOs.  audit_list->next is the first
++   element.  */
+ static struct audit_list
+ {
+   const char *name;
+   struct audit_list *next;
+ } *audit_list;
+ 
++/* Iterator for audit_list_string followed by audit_list.  */
++struct audit_list_iter
++{
++  /* Tail of audit_list_string still needing processing, or NULL.  */
++  const char *audit_list_tail;
++
++  /* The list element returned in the previous iteration.  NULL before
++     the first element.  */
++  struct audit_list *previous;
++
++  /* Scratch buffer for returning a name which is part of
++     audit_list_string.  */
++  char fname[SECURE_NAME_LIMIT];
++};
++
++/* Initialize an audit list iterator.  */
++static void
++audit_list_iter_init (struct audit_list_iter *iter)
++{
++  iter->audit_list_tail = audit_list_string;
++  iter->previous = NULL;
++}
++
++/* Iterate through both audit_list_string and audit_list.  */
++static const char *
++audit_list_iter_next (struct audit_list_iter *iter)
++{
++  if (iter->audit_list_tail != NULL)
++    {
++      /* First iterate over audit_list_string.  */
++      while (*iter->audit_list_tail != '\0')
++	{
++	  /* Split audit list at colon.  */
++	  size_t len = strcspn (iter->audit_list_tail, ":");
++	  if (len > 0 && len < sizeof (iter->fname))
++	    {
++	      memcpy (iter->fname, iter->audit_list_tail, len);
++	      iter->fname[len] = '\0';
++	    }
++	  else
++	    /* Do not return this name to the caller.  */
++	    iter->fname[0] = '\0';
++
++	  /* Skip over the substring and the following delimiter.  */
++	  iter->audit_list_tail += len;
++	  if (*iter->audit_list_tail == ':')
++	    ++iter->audit_list_tail;
++
++	  /* If the name is valid, return it.  */
++	  if (dso_name_valid_for_suid (iter->fname))
++	    return iter->fname;
++	  /* Otherwise, wrap around and try the next name.  */
++	}
++      /* Fall through to the procesing of audit_list.  */
++    }
++
++  if (iter->previous == NULL)
++    {
++      if (audit_list == NULL)
++	/* No pre-parsed audit list.  */
++	return NULL;
++      /* Start of audit list.  The first list element is at
++	 audit_list->next (cyclic list).  */
++      iter->previous = audit_list->next;
++      return iter->previous->name;
++    }
++  if (iter->previous == audit_list)
++    /* Cyclic list wrap-around.  */
++    return NULL;
++  iter->previous = iter->previous->next;
++  return iter->previous->name;
++}
++
+ #ifndef HAVE_INLINED_SYSCALLS
+ /* Set nonzero during loading and initialization of executable and
+    libraries, cleared before the executable's entry point runs.  This
+@@ -730,6 +837,42 @@ static const char *preloadlist attribute_relro;
+ /* Nonzero if information about versions has to be printed.  */
+ static int version_info attribute_relro;
+ 
++/* The LD_PRELOAD environment variable gives list of libraries
++   separated by white space or colons that are loaded before the
++   executable's dependencies and prepended to the global scope list.
++   (If the binary is running setuid all elements containing a '/' are
++   ignored since it is insecure.)  Return the number of preloads
++   performed.  */
++unsigned int
++handle_ld_preload (const char *preloadlist, struct link_map *main_map)
++{
++  unsigned int npreloads = 0;
++  const char *p = preloadlist;
++  char fname[SECURE_PATH_LIMIT];
++
++  while (*p != '\0')
++    {
++      /* Split preload list at space/colon.  */
++      size_t len = strcspn (p, " :");
++      if (len > 0 && len < sizeof (fname))
++	{
++	  memcpy (fname, p, len);
++	  fname[len] = '\0';
++	}
++      else
++	fname[0] = '\0';
++
++      /* Skip over the substring and the following delimiter.  */
++      p += len;
++      if (*p != '\0')
++	++p;
++
++      if (dso_name_valid_for_suid (fname))
++	npreloads += do_preload (fname, main_map, "LD_PRELOAD");
++    }
++  return npreloads;
++}
++
+ static void
+ dl_main (const ElfW(Phdr) *phdr,
+ 	 ElfW(Word) phnum,
+@@ -1257,11 +1400,13 @@ of this helper program; chances are you did not intend to run this program.\n\
+     GL(dl_rtld_map).l_tls_modid = _dl_next_tls_modid ();
+ 
+   /* If we have auditing DSOs to load, do it now.  */
+-  if (__glibc_unlikely (audit_list != NULL))
++  bool need_security_init = true;
++  if (__glibc_unlikely (audit_list != NULL)
++      || __glibc_unlikely (audit_list_string != NULL))
+     {
+-      /* Iterate over all entries in the list.  The order is important.  */
+       struct audit_ifaces *last_audit = NULL;
+-      struct audit_list *al = audit_list->next;
++      struct audit_list_iter al_iter;
++      audit_list_iter_init (&al_iter);
+ 
+       /* Since we start using the auditing DSOs right away we need to
+ 	 initialize the data structures now.  */
+@@ -1272,9 +1417,14 @@ of this helper program; chances are you did not intend to run this program.\n\
+ 	 use different values (especially the pointer guard) and will
+ 	 fail later on.  */
+       security_init ();
++      need_security_init = false;
+ 
+-      do
++      while (true)
+ 	{
++	  const char *name = audit_list_iter_next (&al_iter);
++	  if (name == NULL)
++	    break;
++
+ 	  int tls_idx = GL(dl_tls_max_dtv_idx);
+ 
+ 	  /* Now it is time to determine the layout of the static TLS
+@@ -1283,7 +1433,7 @@ of this helper program; chances are you did not intend to run this program.\n\
+ 	     no DF_STATIC_TLS bit is set.  The reason is that we know
+ 	     glibc will use the static model.  */
+ 	  struct dlmopen_args dlmargs;
+-	  dlmargs.fname = al->name;
++	  dlmargs.fname = name;
+ 	  dlmargs.map = NULL;
+ 
+ 	  const char *objname;
+@@ -1296,7 +1446,7 @@ of this helper program; chances are you did not intend to run this program.\n\
+ 	    not_loaded:
+ 	      _dl_error_printf ("\
+ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
+-				al->name, err_str);
++				name, err_str);
+ 	      if (malloced)
+ 		free ((char *) err_str);
+ 	    }
+@@ -1400,10 +1550,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
+ 		  goto not_loaded;
+ 		}
+ 	    }
+-
+-	  al = al->next;
+ 	}
+-      while (al != audit_list->next);
+ 
+       /* If we have any auditing modules, announce that we already
+ 	 have two objects loaded.  */
+@@ -1481,23 +1628,8 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
+ 
+   if (__glibc_unlikely (preloadlist != NULL))
+     {
+-      /* The LD_PRELOAD environment variable gives list of libraries
+-	 separated by white space or colons that are loaded before the
+-	 executable's dependencies and prepended to the global scope
+-	 list.  If the binary is running setuid all elements
+-	 containing a '/' are ignored since it is insecure.  */
+-      char *list = strdupa (preloadlist);
+-      char *p;
+-
+       HP_TIMING_NOW (start);
+-
+-      /* Prevent optimizing strsep.  Speed is not important here.  */
+-      while ((p = (strsep) (&list, " :")) != NULL)
+-	if (p[0] != '\0'
+-	    && (__builtin_expect (! __libc_enable_secure, 1)
+-		|| strchr (p, '/') == NULL))
+-	  npreloads += do_preload (p, main_map, "LD_PRELOAD");
+-
++      npreloads += handle_ld_preload (preloadlist, main_map);
+       HP_TIMING_NOW (stop);
+       HP_TIMING_DIFF (diff, start, stop);
+       HP_TIMING_ACCUM_NT (load_time, diff);
+@@ -1682,7 +1814,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n",
+   if (tcbp == NULL)
+     tcbp = init_tls ();
+ 
+-  if (__glibc_likely (audit_list == NULL))
++  if (__glibc_likely (need_security_init))
+     /* Initialize security features.  But only if we have not done it
+        earlier.  */
+     security_init ();
+@@ -2313,9 +2445,7 @@ process_dl_audit (char *str)
+   char *p;
+ 
+   while ((p = (strsep) (&str, ":")) != NULL)
+-    if (p[0] != '\0'
+-	&& (__builtin_expect (! __libc_enable_secure, 1)
+-	    || strchr (p, '/') == NULL))
++    if (dso_name_valid_for_suid (p))
+       {
+ 	/* This is using the local malloc, not the system malloc.  The
+ 	   memory can never be freed.  */
+@@ -2379,7 +2509,7 @@ process_envvars (enum mode *modep)
+ 	      break;
+ 	    }
+ 	  if (memcmp (envline, "AUDIT", 5) == 0)
+-	    process_dl_audit (&envline[6]);
++	    audit_list_string = &envline[6];
+ 	  break;
+ 
+ 	case 7:
+@@ -2423,7 +2553,8 @@ process_envvars (enum mode *modep)
+ 
+ 	case 10:
+ 	  /* Mask for the important hardware capabilities.  */
+-	  if (memcmp (envline, "HWCAP_MASK", 10) == 0)
++	  if (!__libc_enable_secure
++	      && memcmp (envline, "HWCAP_MASK", 10) == 0)
+ 	    GLRO(dl_hwcap_mask) = __strtoul_internal (&envline[11], NULL,
+ 						      0, 0);
+ 	  break;
+@@ -2437,7 +2568,8 @@ process_envvars (enum mode *modep)
+ 
+ 	case 12:
+ 	  /* The library search path.  */
+-	  if (memcmp (envline, "LIBRARY_PATH", 12) == 0)
++	  if (!__libc_enable_secure
++	      && memcmp (envline, "LIBRARY_PATH", 12) == 0)
+ 	    {
+ 	      library_path = &envline[13];
+ 	      break;
+diff --git a/elf/tst-nodelete-dlclose-dso.c b/elf/tst-nodelete-dlclose-dso.c
+new file mode 100644
+index 0000000000..dd930f99cc
+--- /dev/null
++++ b/elf/tst-nodelete-dlclose-dso.c
+@@ -0,0 +1,90 @@
++/* Bug 11941: Improper assert map->l_init_called in dlclose.
++   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 is the primary DSO that is loaded by the appliation.  This DSO
++   then loads a plugin with RTLD_NODELETE.  This plugin depends on this
++   DSO.  This dependency chain means that at application shutdown the
++   plugin will be destructed first.  Thus by the time this DSO is
++   destructed we will be calling dlclose on an object that has already
++   been destructed.  It is allowed to call dlclose in this way and
++   should not assert.  */
++#include <stdio.h>
++#include <stdlib.h>
++#include <dlfcn.h>
++
++/* Plugin to load.  */
++static void *plugin_lib = NULL;
++/* Plugin function.  */
++static void (*plugin_func) (void);
++#define LIB_PLUGIN "tst-nodelete-dlclose-plugin.so"
++
++/* This function is never called but the plugin references it.
++   We do this to avoid any future --as-needed from removing the
++   plugin's DT_NEEDED on this DSO (required for the test).  */
++void
++primary_reference (void)
++{
++  printf ("INFO: Called primary_reference function.\n");
++}
++
++void
++primary (void)
++{
++  char *error;
++
++  plugin_lib = dlopen (LIB_PLUGIN, RTLD_NOW | RTLD_LOCAL | RTLD_NODELETE);
++  if (plugin_lib == NULL)
++    {
++      printf ("ERROR: Unable to load plugin library.\n");
++      exit (EXIT_FAILURE);
++    }
++  dlerror ();
++
++  plugin_func = (void (*) (void)) dlsym (plugin_lib, "plugin_func");
++  error = dlerror ();
++  if (error != NULL)
++    {
++      printf ("ERROR: Unable to find symbol with error \"%s\".",
++	      error);
++      exit (EXIT_FAILURE);
++    }
++
++  return;
++}
++
++__attribute__ ((destructor))
++static void
++primary_dtor (void)
++{
++  int ret;
++
++  printf ("INFO: Calling primary destructor.\n");
++
++  /* The destructor runs in the test driver also, which
++     hasn't called primary, in that case do nothing.  */
++  if (plugin_lib == NULL)
++    return;
++
++  ret = dlclose (plugin_lib);
++  if (ret != 0)
++    {
++      printf ("ERROR: Calling dlclose failed with \"%s\"\n",
++	      dlerror ());
++      exit (EXIT_FAILURE);
++    }
++}
+diff --git a/elf/tst-nodelete-dlclose-plugin.c b/elf/tst-nodelete-dlclose-plugin.c
+new file mode 100644
+index 0000000000..8b295c1718
+--- /dev/null
++++ b/elf/tst-nodelete-dlclose-plugin.c
+@@ -0,0 +1,40 @@
++/* Bug 11941: Improper assert map->l_init_called in dlclose.
++   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 DSO simulates a plugin with a dependency on the
++   primary DSO loaded by the appliation.  */
++#include <stdio.h>
++
++extern void primary_reference (void);
++
++void
++plugin_func (void)
++{
++  printf ("INFO: Calling plugin function.\n");
++  /* Need a reference to the DSO to ensure that a potential --as-needed
++     doesn't remove the DT_NEEDED entry which we rely upon to ensure
++     destruction ordering.  */
++  primary_reference ();
++}
++
++__attribute__ ((destructor))
++static void
++plugin_dtor (void)
++{
++  printf ("INFO: Calling plugin destructor.\n");
++}
+diff --git a/elf/tst-nodelete-dlclose.c b/elf/tst-nodelete-dlclose.c
+new file mode 100644
+index 0000000000..b3d07e1849
+--- /dev/null
++++ b/elf/tst-nodelete-dlclose.c
+@@ -0,0 +1,36 @@
++/* Bug 11941: Improper assert map->l_init_called in dlclose.
++   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 simulates an application using the primary DSO which loads the
++   plugin DSO.  */
++#include <stdio.h>
++#include <stdlib.h>
++
++extern void primary (void);
++
++static int
++do_test (void)
++{
++  printf ("INFO: Starting application.\n");
++  primary ();
++  printf ("INFO: Exiting application.\n");
++  return 0;
++}
++
++#define TEST_FUNCTION do_test ()
++#include "../test-skeleton.c"
+diff --git a/extra-lib.mk b/extra-lib.mk
+index b10748d185..2552049135 100644
+--- a/extra-lib.mk
++++ b/extra-lib.mk
+@@ -5,6 +5,9 @@
+ # The variable $($(lib)-routines) defines the list of modules
+ # to be included in that library.  A sysdep Makefile can add to
+ # $(lib)-sysdep_routines to include additional modules.
++#
++# Libraries listed in $(extra-libs-noinstall) are built, but not
++# installed.
+ 
+ lib := $(firstword $(extra-libs-left))
+ extra-libs-left := $(filter-out $(lib),$(extra-libs-left))
+@@ -28,7 +31,9 @@ extra-objs := $(extra-objs)
+ all-$(lib)-routines := $($(lib)-routines) $($(lib)-sysdep_routines)
+ 
+ # Add each flavor of library to the lists of things to build and install.
++ifeq (,$(filter $(lib), $(extra-libs-noinstall)))
+ install-lib += $(foreach o,$(object-suffixes-$(lib)),$(lib:lib%=$(libtype$o)))
++endif
+ extra-objs += $(foreach o,$(filter-out .os .oS,$(object-suffixes-$(lib))),\
+ 			$(patsubst %,%$o,$(filter-out \
+ 					   $($(lib)-shared-only-routines),\
+diff --git a/grp/grp-merge.c b/grp/grp-merge.c
+index 0a1eb38d2c..5f79755798 100644
+--- a/grp/grp-merge.c
++++ b/grp/grp-merge.c
+@@ -85,6 +85,14 @@ __copy_grp (const struct group srcgrp, const size_t buflen,
+     }
+   members[i] = NULL;
+ 
++  /* Align for pointers.  We can't simply align C because we need to
++     align destbuf[c].  */
++  if ((((uintptr_t)destbuf + c) & (__alignof__(char **) - 1)) != 0)
++    {
++      uintptr_t mis_align = ((uintptr_t)destbuf + c) & (__alignof__(char **) - 1);
++      c += __alignof__(char **) - mis_align;
++    }
++
+   /* Copy the pointers from the members array into the buffer and assign them
+      to the gr_mem member of destgrp.  */
+   destgrp->gr_mem = (char **) &destbuf[c];
+@@ -129,7 +137,7 @@ __merge_grp (struct group *savedgrp, char *savedbuf, char *savedend,
+ 
+   /* Get the count of group members from the last sizeof (size_t) bytes in the
+      mergegrp buffer.  */
+-  savedmemcount = (size_t) *(savedend - sizeof (size_t));
++  savedmemcount = *(size_t *) (savedend - sizeof (size_t));
+ 
+   /* Get the count of new members to add.  */
+   for (memcount = 0; mergegrp->gr_mem[memcount]; memcount++)
+@@ -168,6 +176,14 @@ __merge_grp (struct group *savedgrp, char *savedbuf, char *savedend,
+   /* Add the NULL-terminator.  */
+   members[savedmemcount + memcount] = NULL;
+ 
++  /* Align for pointers.  We can't simply align C because we need to
++     align savedbuf[c].  */
++  if ((((uintptr_t)savedbuf + c) & (__alignof__(char **) - 1)) != 0)
++    {
++      uintptr_t mis_align = ((uintptr_t)savedbuf + c) & (__alignof__(char **) - 1);
++      c += __alignof__(char **) - mis_align;
++    }
++
+   /* Copy the member array back into the buffer after the member list and free
+      the member array.  */
+   savedgrp->gr_mem = (char **) &savedbuf[c];
+diff --git a/iconv/gconv.h b/iconv/gconv.h
+index 8d8ce5813b..a87028047b 100644
+--- a/iconv/gconv.h
++++ b/iconv/gconv.h
+@@ -139,7 +139,7 @@ typedef struct __gconv_info
+ {
+   size_t __nsteps;
+   struct __gconv_step *__steps;
+-  __extension__ struct __gconv_step_data __data __flexarr;
++  __extension__ struct __gconv_step_data __data[0];
+ } *__gconv_t;
+ 
+ /* Transliteration using the locale's data.  */
+diff --git a/include/arpa/nameser_compat.h b/include/arpa/nameser_compat.h
+index 2e735ede4c..7c0deed9ae 100644
+--- a/include/arpa/nameser_compat.h
++++ b/include/arpa/nameser_compat.h
+@@ -1,8 +1,8 @@
+ #ifndef _ARPA_NAMESER_COMPAT_
+ #include <resolv/arpa/nameser_compat.h>
+ 
+-/* Picksome unused number to represent lookups of IPv4 and IPv6 (i.e.,
+-   T_A and T_AAAA).  */
+-#define T_UNSPEC 62321
++/* The number is outside the 16-bit RR type range and is used
++   internally by the implementation.  */
++#define T_QUERY_A_AND_AAAA 439963904
+ 
+ #endif
+diff --git a/include/array_length.h b/include/array_length.h
+new file mode 100644
+index 0000000000..cb4a8b2a56
+--- /dev/null
++++ b/include/array_length.h
+@@ -0,0 +1,36 @@
++/* The array_length and array_end macros.
++   Copyright (C) 2017 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/>.  */
++
++#ifndef _ARRAY_LENGTH_H
++#define _ARRAY_LENGTH_H
++
++/* array_length (VAR) is the number of elements in the array VAR.  VAR
++   must evaluate to an array, not a pointer.  */
++#define array_length(var)                                               \
++  __extension__ ({                                                      \
++    _Static_assert (!__builtin_types_compatible_p                       \
++                    (__typeof (var), __typeof (&(var)[0])),             \
++                    "argument must be an array");                       \
++    sizeof (var) / sizeof ((var)[0]);                                   \
++  })
++
++/* array_end (VAR) is a pointer one past the end of the array VAR.
++   VAR must evaluate to an array, not a pointer.  */
++#define array_end(var) (&(var)[array_length (var)])
++
++#endif /* _ARRAY_LENGTH_H */
+diff --git a/io/Makefile b/io/Makefile
+index deb6100156..1128f4881f 100644
+--- a/io/Makefile
++++ b/io/Makefile
+@@ -71,7 +71,8 @@ tests		:= test-utime test-stat test-stat2 test-lfs tst-getcwd \
+ 		   tst-renameat tst-fchownat tst-fchmodat tst-faccessat \
+ 		   tst-symlinkat tst-linkat tst-readlinkat tst-mkdirat \
+ 		   tst-mknodat tst-mkfifoat tst-ttyname_r bug-ftw5 \
+-		   tst-posix_fallocate tst-fts tst-fts-lfs
++		   tst-posix_fallocate tst-posix_fallocate64 \
++		   tst-fts tst-fts-lfs tst-open-tmpfile tst-getcwd-abspath
+ 
+ ifeq ($(run-built-tests),yes)
+ tests-special += $(objpfx)ftwtest.out
+diff --git a/io/fts.h b/io/fts.h
+index 127a0d2721..b6b45206c8 100644
+--- a/io/fts.h
++++ b/io/fts.h
+@@ -193,7 +193,7 @@ FTS	*__REDIRECT (fts_open, (char * const *, int,
+ 				int (*)(const FTSENT **, const FTSENT **)),
+ 		     fts64_open);
+ FTSENT	*__REDIRECT (fts_read, (FTS *), fts64_read);
+-int	 __REDIRECT (fts_set, (FTS *, FTSENT *, int), fts64_set) __THROW;
++int	 __REDIRECT_NTH (fts_set, (FTS *, FTSENT *, int), fts64_set);
+ # else
+ #  define fts_children fts64_children
+ #  define fts_close fts64_close
+diff --git a/io/tst-getcwd-abspath.c b/io/tst-getcwd-abspath.c
+new file mode 100644
+index 0000000000..3a3636f2ed
+--- /dev/null
++++ b/io/tst-getcwd-abspath.c
+@@ -0,0 +1,66 @@
++/* BZ #22679 getcwd(3) should not succeed without returning an absolute path.
++
++   Copyright (C) 2018 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
++   <https://www.gnu.org/licenses/>.  */
++
++#include <errno.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++#include <support/namespace.h>
++#include <support/support.h>
++#include <support/temp_file.h>
++#include <support/test-driver.h>
++#include <support/xunistd.h>
++#include <unistd.h>
++
++static char *chroot_dir;
++
++/* The actual test.  Run it in a subprocess, so that the test harness
++   can remove the temporary directory in --direct mode.  */
++static void
++getcwd_callback (void *closure)
++{
++  xchroot (chroot_dir);
++
++  errno = 0;
++  char *cwd = getcwd (NULL, 0);
++  TEST_COMPARE (errno, ENOENT);
++  TEST_VERIFY (cwd == NULL);
++
++  errno = 0;
++  cwd = realpath (".", NULL);
++  TEST_COMPARE (errno, ENOENT);
++  TEST_VERIFY (cwd == NULL);
++
++  _exit (0);
++}
++
++static int
++do_test (void)
++{
++  support_become_root ();
++  if (!support_can_chroot ())
++    return EXIT_UNSUPPORTED;
++
++  chroot_dir = support_create_temp_directory ("tst-getcwd-abspath-");
++  support_isolate_in_subprocess (getcwd_callback, NULL);
++
++  return 0;
++}
++
++#include <support/test-driver.c>
+diff --git a/localedata/ChangeLog b/localedata/ChangeLog
+index 4be8afc110..a7688e3df6 100644
+--- a/localedata/ChangeLog
++++ b/localedata/ChangeLog
+@@ -1,3 +1,17 @@
++2017-06-11  Santhosh Thottingal  <santhosh.thottingal@gmail.com>
++
++	[BZ #19922]
++	* locales/iso14651_t1_common: Add collation rules for U+07DA to U+07DF.
++
++	[BZ #19919]
++	* locales/iso14651_t1_common: Correct collation of U+0D36 and U+0D37.
++
++2016-12-30  Mike Frysinger  <vapier@gentoo.org>
++
++	[BZ #20974]
++	* localedata/bs_BA (LC_MESSAGES): Delete "*." from the end of
++	yesexpr and noexpr.
++
+ 2016-07-07  Aurelien Jarno  <aurelien@aurel32.net>
+ 
+ 	* locales/de_LI (postal_fmt): Fix indentation.
+diff --git a/localedata/locales/bs_BA b/localedata/locales/bs_BA
+index a47f87eb37..68c2f9471a 100644
+--- a/localedata/locales/bs_BA
++++ b/localedata/locales/bs_BA
+@@ -148,8 +148,8 @@ copy "en_DK"
+ END LC_CTYPE
+ 
+ LC_MESSAGES
+-yesexpr "<U005E><U005B><U002B><U0031><U0064><U0044><U0079><U0059><U005D><U002A><U002E>"
+-noexpr  "<U005E><U005B><U002D><U0030><U006E><U004E><U005D><U002A><U002E>"
++yesexpr "<U005E><U005B><U002B><U0031><U0064><U0044><U0079><U0059><U005D>"
++noexpr  "<U005E><U005B><U002D><U0030><U006E><U004E><U005D>"
+ yesstr  "<U0064><U0061>"
+ nostr   "<U006E><U0065>"
+ END LC_MESSAGES
+diff --git a/localedata/locales/iso14651_t1_common b/localedata/locales/iso14651_t1_common
+index eef75ba65e..0e64f26a12 100644
+--- a/localedata/locales/iso14651_t1_common
++++ b/localedata/locales/iso14651_t1_common
+@@ -1042,9 +1042,9 @@ collating-element <ml-bh> from "<U0D2D><U0D4D>"
+ collating-element <ml-m> from "<U0D2E><U0D4D>"
+ collating-element <ml-y> from "<U0D2F><U0D4D>"
+ collating-element <ml-v> from "<U0D35><U0D4D>"
+-collating-element <ml-s> from "<U0D38><U0D4D>"
+ collating-element <ml-ss> from "<U0D36><U0D4D>"
+ collating-element <ml-sh> from "<U0D37><U0D4D>"
++collating-element <ml-s> from "<U0D38><U0D4D>"
+ collating-element <ml-h> from "<U0D39><U0D4D>"
+ collating-element <ml-zh> from "<U0D34><U0D4D>"
+ collating-element <ml-rr> from "<U0D31><U0D4D>"
+@@ -1103,8 +1103,8 @@ collating-symbol <ml-rra>
+ collating-symbol <ml-la>
+ collating-symbol <ml-lla>
+ collating-symbol <ml-va>
+-collating-symbol <ml-sha>
+ collating-symbol <ml-ssa>
++collating-symbol <ml-sha>
+ collating-symbol <ml-sa>
+ collating-symbol <ml-ha>
+ collating-symbol <ml-avagrah>
+@@ -1126,6 +1126,12 @@ collating-symbol <mlvs-o>
+ collating-symbol <mlvs-au>
+ collating-symbol <ml-visarga>
+ collating-symbol <ml-virama>
++collating-symbol <ml-atomic-chillu-k>
++collating-symbol <ml-atomic-chillu-n>
++collating-symbol <ml-atomic-chillu-nn>
++collating-symbol <ml-atomic-chillu-l>
++collating-symbol <ml-atomic-chillu-ll>
++collating-symbol <ml-atomic-chillu-r>
+ #
+ # <BENGALI>
+ #
+@@ -4552,6 +4558,12 @@ collating-symbol <TIB-subA>
+ <mlvs-o>
+ <mlvs-au>
+ <ml-visarga>
++<ml-atomic-chillu-k>
++<ml-atomic-chillu-n>
++<ml-atomic-chillu-nn>
++<ml-atomic-chillu-l>
++<ml-atomic-chillu-ll>
++<ml-atomic-chillu-r>
+ #
+ # <BENGALI>
+ #
+@@ -7252,6 +7264,7 @@ order_start <MALAYALAM>;forward;forward;forward;forward,position
+ <U0D13> <mlvw-o>;<BAS>;<MIN>;IGNORE
+ <U0D14> <mlvw-au>;<BAS>;<MIN>;IGNORE
+ <ml-chillu-k>  "<ml-ka><ml-virama>";<BAS>;<MIN>;IGNORE
++<U0D7F>	"<ml-ka><ml-virama>";<ml-atomic-chillu-k>;<MIN>;IGNORE
+ <U0D15>	"<ml-ka><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+ <ml-kh>	"<ml-kha><ml-virama>";<BAS>;<MIN>;IGNORE
+ <U0D16>	"<ml-kha><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+@@ -7280,6 +7293,7 @@ order_start <MALAYALAM>;forward;forward;forward;forward,position
+ <ml-dh>	"<ml-dha><ml-virama>";<BAS>;<MIN>;IGNORE
+ <U0D22>	"<ml-dha><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+ <ml-chillu-nn> "<ml-nna><ml-virama>";<BAS>;<MIN>;IGNORE # ????????? = ???  + ???  + zwj
++<U0D7A>	"<ml-nna><ml-virama>";<ml-atomic-chillu-nn>;<MIN>;IGNORE
+ <U0D23>	"<ml-nna><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE # ??? = ??? + ??? + ???
+ <ml-th>	"<ml-tha><ml-virama>";<BAS>;<MIN>;IGNORE
+ <U0D24>	"<ml-tha><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+@@ -7290,6 +7304,7 @@ order_start <MALAYALAM>;forward;forward;forward;forward,position
+ <ml-ddh> "<ml-ddha><ml-virama>";<BAS>;<MIN>;IGNORE
+ <U0D27>	"<ml-ddha><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+ <ml-chillu-n> "<ml-na><ml-virama>";<BAS>;<MIN>;IGNORE # ?????????= ???  + ???  + zwj
++<U0D7B>	"<ml-na><ml-virama>";<ml-atomic-chillu-n>;<MIN>;IGNORE
+ <U0D28>	"<ml-na><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE  #??? = ??? + ??? + ???
+ <ml-p>	"<ml-pa><ml-virama>";<BAS>;<MIN>;IGNORE
+ <U0D2A>	"<ml-pa><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+@@ -7305,20 +7320,23 @@ order_start <MALAYALAM>;forward;forward;forward;forward,position
+ <ml-y>  "<ml-ya><ml-virama>";<BAS>;<MIN>;IGNORE
+ <U0D2F>	"<ml-ya><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+ <ml-chillu-r> "<ml-ra><ml-virama>";<BAS>;<MIN>;IGNORE # ??? = ??? + ???  + zwj
++<U0D7C>	"<ml-ra><ml-virama>";<ml-atomic-chillu-r>;<MIN>;IGNORE
+ <U0D30>	"<ml-ra><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE # ??? = ??? + ??? + ???
+ <ml-chillu-l> <ml-la>;<BAS>;<MIN>;IGNORE # ????????? = ??? + ???  + zwj
++<U0D7D>	"<ml-la><ml-virama>";<ml-atomic-chillu-l>;<MIN>;IGNORE
+ <U0D32>	"<ml-la><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE # ??? = ??? + ??? + ???
+ <ml-v>	"<ml-va><ml-virama>";<BAS>;<MIN>;IGNORE
+ <U0D35>	"<ml-va><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+ <ml-ss>	"<ml-ssa><ml-virama>";<BAS>;<MIN>;IGNORE
+-<U0D37>	"<ml-ssa><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
++<U0D36>	"<ml-ssa><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+ <ml-sh>	"<ml-sha><ml-virama>";<BAS>;<MIN>;IGNORE
+-<U0D36>	"<ml-sha><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
++<U0D37>	"<ml-sha><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+ <ml-s>	"<ml-sa><ml-virama>";<BAS>;<MIN>;IGNORE
+ <U0D38>	"<ml-sa><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+ <ml-h>	"<ml-ha><ml-virama>";<BAS>;<MIN>;IGNORE
+ <U0D39>	"<ml-ha><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+ <ml-chillu-ll> "<ml-lla><ml-virama>";<BAS>;<MIN>;IGNORE # ????????? = ???  + ???  + zwj
++<U0D7E>	"<ml-lla><ml-virama>";<ml-atomic-chillu-ll>;<MIN>;IGNORE
+ <U0D33>	"<ml-lla><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE # ??? = ??? + ??? + ???
+ <ml-zh>	"<ml-zha><ml-virama>";<BAS>;<MIN>;IGNORE
+ <U0D34>	"<ml-zha><ml-virama><mlvw-shorta>";<BAS>;<MIN>;IGNORE
+diff --git a/malloc/arena.c b/malloc/arena.c
+index 229783f3b7..4e16593d8b 100644
+--- a/malloc/arena.c
++++ b/malloc/arena.c
+@@ -702,8 +702,7 @@ _int_new_arena (size_t size)
+ }
+ 
+ 
+-/* Remove an arena from free_list.  The arena may be in use because it
+-   was attached concurrently to a thread by reused_arena below.  */
++/* Remove an arena from free_list.  */
+ static mstate
+ get_free_list (void)
+ {
+@@ -718,7 +717,8 @@ get_free_list (void)
+ 	  free_list = result->next_free;
+ 
+ 	  /* The arena will be attached to this thread.  */
+-	  ++result->attached_threads;
++	  assert (result->attached_threads == 0);
++	  result->attached_threads = 1;
+ 
+ 	  detach_arena (replaced_arena);
+ 	}
+@@ -735,6 +735,26 @@ get_free_list (void)
+   return result;
+ }
+ 
++/* Remove the arena from the free list (if it is present).
++   free_list_lock must have been acquired by the caller.  */
++static void
++remove_from_free_list (mstate arena)
++{
++  mstate *previous = &free_list;
++  for (mstate p = free_list; p != NULL; p = p->next_free)
++    {
++      assert (p->attached_threads == 0);
++      if (p == arena)
++	{
++	  /* Remove the requested arena from the list.  */
++	  *previous = p->next_free;
++	  break;
++	}
++      else
++	previous = &p->next_free;
++    }
++}
++
+ /* Lock and return an arena that can be reused for memory allocation.
+    Avoid AVOID_ARENA as we have already failed to allocate memory in
+    it and it is currently locked.  */
+@@ -782,14 +802,25 @@ reused_arena (mstate avoid_arena)
+   (void) mutex_lock (&result->mutex);
+ 
+ out:
+-  /* Attach the arena to the current thread.  Note that we may have
+-     selected an arena which was on free_list.  */
++  /* Attach the arena to the current thread.  */
+   {
+     /* Update the arena thread attachment counters.   */
+     mstate replaced_arena = thread_arena;
+     (void) mutex_lock (&free_list_lock);
+     detach_arena (replaced_arena);
++
++    /* We may have picked up an arena on the free list.  We need to
++       preserve the invariant that no arena on the free list has a
++       positive attached_threads counter (otherwise,
++       arena_thread_freeres cannot use the counter to determine if the
++       arena needs to be put on the free list).  We unconditionally
++       remove the selected arena from the free list.  The caller of
++       reused_arena checked the free list and observed it to be empty,
++       so the list is very short.  */
++    remove_from_free_list (result);
++
+     ++result->attached_threads;
++
+     (void) mutex_unlock (&free_list_lock);
+   }
+ 
+diff --git a/misc/regexp.c b/misc/regexp.c
+index 3b3668272f..b2a2c6e636 100644
+--- a/misc/regexp.c
++++ b/misc/regexp.c
+@@ -29,14 +29,15 @@
+ 
+ #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_23)
+ 
+-/* Define the variables used for the interface.  */
+-char *loc1;
+-char *loc2;
++/* Define the variables used for the interface.  Avoid .symver on common
++   symbol, which just creates a new common symbol, not an alias.  */
++char *loc1 __attribute__ ((nocommon));
++char *loc2 __attribute__ ((nocommon));
+ compat_symbol (libc, loc1, loc1, GLIBC_2_0);
+ compat_symbol (libc, loc2, loc2, GLIBC_2_0);
+ 
+ /* Although we do not support the use we define this variable as well.  */
+-char *locs;
++char *locs __attribute__ ((nocommon));
+ compat_symbol (libc, locs, locs, GLIBC_2_0);
+ 
+ 
+diff --git a/nis/nss_nisplus/nisplus-alias.c b/nis/nss_nisplus/nisplus-alias.c
+index 7f698b4e6d..cb5acce01d 100644
+--- a/nis/nss_nisplus/nisplus-alias.c
++++ b/nis/nss_nisplus/nisplus-alias.c
+@@ -291,7 +291,7 @@ _nss_nisplus_getaliasbyname_r (const char *name, struct aliasent *alias,
+ 	return status;
+     }
+ 
+-  if (name != NULL)
++  if (name == NULL)
+     {
+       *errnop = EINVAL;
+       return NSS_STATUS_UNAVAIL;
+diff --git a/nptl/Makefile b/nptl/Makefile
+index 0d8aadebed..fa925819ca 100644
+--- a/nptl/Makefile
++++ b/nptl/Makefile
+@@ -268,7 +268,7 @@ tests = tst-typesizes \
+ 	tst-flock1 tst-flock2 \
+ 	tst-signal1 tst-signal2 tst-signal3 tst-signal4 tst-signal5 \
+ 	tst-signal6 tst-signal7 \
+-	tst-exec1 tst-exec2 tst-exec3 tst-exec4 \
++	tst-exec1 tst-exec2 tst-exec3 tst-exec4 tst-exec5 \
+ 	tst-exit1 tst-exit2 tst-exit3 \
+ 	tst-stdio1 tst-stdio2 \
+ 	tst-stack1 tst-stack2 tst-stack3 tst-stack4 tst-pthread-getattr \
+diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c
+index 6b42b11d5a..7365ca606b 100644
+--- a/nptl/allocatestack.c
++++ b/nptl/allocatestack.c
+@@ -440,9 +440,6 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp,
+       SETUP_THREAD_SYSINFO (pd);
+ #endif
+ 
+-      /* The process ID is also the same as that of the caller.  */
+-      pd->pid = THREAD_GETMEM (THREAD_SELF, pid);
+-
+       /* Don't allow setxid until cloned.  */
+       pd->setxid_futex = -1;
+ 
+@@ -579,9 +576,6 @@ allocate_stack (const struct pthread_attr *attr, struct pthread **pdp,
+ 	  /* Don't allow setxid until cloned.  */
+ 	  pd->setxid_futex = -1;
+ 
+-	  /* The process ID is also the same as that of the caller.  */
+-	  pd->pid = THREAD_GETMEM (THREAD_SELF, pid);
+-
+ 	  /* Allocate the DTV for this thread.  */
+ 	  if (_dl_allocate_tls (TLS_TPADJ (pd)) == NULL)
+ 	    {
+@@ -875,9 +869,6 @@ __reclaim_stacks (void)
+ 	  /* This marks the stack as free.  */
+ 	  curp->tid = 0;
+ 
+-	  /* The PID field must be initialized for the new process.  */
+-	  curp->pid = self->pid;
+-
+ 	  /* Account for the size of the stack.  */
+ 	  stack_cache_actsize += curp->stackblock_size;
+ 
+@@ -903,13 +894,6 @@ __reclaim_stacks (void)
+ 	}
+     }
+ 
+-  /* Reset the PIDs in any cached stacks.  */
+-  list_for_each (runp, &stack_cache)
+-    {
+-      struct pthread *curp = list_entry (runp, struct pthread, list);
+-      curp->pid = self->pid;
+-    }
+-
+   /* Add the stack of all running threads to the cache.  */
+   list_splice (&stack_used, &stack_cache);
+ 
+@@ -1054,9 +1038,9 @@ setxid_signal_thread (struct xid_command *cmdp, struct pthread *t)
+     return 0;
+ 
+   int val;
++  pid_t pid = __getpid ();
+   INTERNAL_SYSCALL_DECL (err);
+-  val = INTERNAL_SYSCALL (tgkill, err, 3, THREAD_GETMEM (THREAD_SELF, pid),
+-			  t->tid, SIGSETXID);
++  val = INTERNAL_SYSCALL_CALL (tgkill, err, pid, t->tid, SIGSETXID);
+ 
+   /* If this failed, it must have had not started yet or else exited.  */
+   if (!INTERNAL_SYSCALL_ERROR_P (val, err))
+diff --git a/nptl/descr.h b/nptl/descr.h
+index 8e4938deb5..bc92abf010 100644
+--- a/nptl/descr.h
++++ b/nptl/descr.h
+@@ -167,8 +167,8 @@ struct pthread
+      therefore stack) used' flag.  */
+   pid_t tid;
+ 
+-  /* Process ID - thread group ID in kernel speak.  */
+-  pid_t pid;
++  /* Ununsed.  */
++  pid_t pid_ununsed;
+ 
+   /* List of robust mutexes the thread is holding.  */
+ #ifdef __PTHREAD_MUTEX_HAVE_PREV
+diff --git a/nptl/nptl-init.c b/nptl/nptl-init.c
+index bdbdfedcef..48fab50c4e 100644
+--- a/nptl/nptl-init.c
++++ b/nptl/nptl-init.c
+@@ -184,18 +184,12 @@ __nptl_set_robust (struct pthread *self)
+ static void
+ sigcancel_handler (int sig, siginfo_t *si, void *ctx)
+ {
+-  /* Determine the process ID.  It might be negative if the thread is
+-     in the middle of a fork() call.  */
+-  pid_t pid = THREAD_GETMEM (THREAD_SELF, pid);
+-  if (__glibc_unlikely (pid < 0))
+-    pid = -pid;
+-
+   /* Safety check.  It would be possible to call this function for
+      other signals and send a signal from another process.  This is not
+      correct and might even be a security problem.  Try to catch as
+      many incorrect invocations as possible.  */
+   if (sig != SIGCANCEL
+-      || si->si_pid != pid
++      || si->si_pid != __getpid()
+       || si->si_code != SI_TKILL)
+     return;
+ 
+@@ -243,19 +237,14 @@ struct xid_command *__xidcmd attribute_hidden;
+ static void
+ sighandler_setxid (int sig, siginfo_t *si, void *ctx)
+ {
+-  /* Determine the process ID.  It might be negative if the thread is
+-     in the middle of a fork() call.  */
+-  pid_t pid = THREAD_GETMEM (THREAD_SELF, pid);
+   int result;
+-  if (__glibc_unlikely (pid < 0))
+-    pid = -pid;
+ 
+   /* Safety check.  It would be possible to call this function for
+      other signals and send a signal from another process.  This is not
+      correct and might even be a security problem.  Try to catch as
+      many incorrect invocations as possible.  */
+   if (sig != SIGSETXID
+-      || si->si_pid != pid
++      || si->si_pid != __getpid ()
+       || si->si_code != SI_TKILL)
+     return;
+ 
+diff --git a/nptl/pthread_cancel.c b/nptl/pthread_cancel.c
+index 1419baf988..89d02e1741 100644
+--- a/nptl/pthread_cancel.c
++++ b/nptl/pthread_cancel.c
+@@ -22,7 +22,7 @@
+ #include "pthreadP.h"
+ #include <atomic.h>
+ #include <sysdep.h>
+-
++#include <unistd.h>
+ 
+ int
+ pthread_cancel (pthread_t th)
+@@ -66,19 +66,11 @@ pthread_cancel (pthread_t th)
+ #ifdef SIGCANCEL
+ 	  /* The cancellation handler will take care of marking the
+ 	     thread as canceled.  */
+-	  INTERNAL_SYSCALL_DECL (err);
+-
+-	  /* One comment: The PID field in the TCB can temporarily be
+-	     changed (in fork).  But this must not affect this code
+-	     here.  Since this function would have to be called while
+-	     the thread is executing fork, it would have to happen in
+-	     a signal handler.  But this is no allowed, pthread_cancel
+-	     is not guaranteed to be async-safe.  */
+-	  int val;
+-	  val = INTERNAL_SYSCALL (tgkill, err, 3,
+-				  THREAD_GETMEM (THREAD_SELF, pid), pd->tid,
+-				  SIGCANCEL);
++	  pid_t pid = getpid ();
+ 
++	  INTERNAL_SYSCALL_DECL (err);
++	  int val = INTERNAL_SYSCALL_CALL (tgkill, err, pid, pd->tid,
++					   SIGCANCEL);
+ 	  if (INTERNAL_SYSCALL_ERROR_P (val, err))
+ 	    result = INTERNAL_SYSCALL_ERRNO (val, err);
+ #else
+diff --git a/nptl/pthread_getattr_np.c b/nptl/pthread_getattr_np.c
+index fb906f0484..32d7484bf8 100644
+--- a/nptl/pthread_getattr_np.c
++++ b/nptl/pthread_getattr_np.c
+@@ -68,7 +68,6 @@ pthread_getattr_np (pthread_t thread_id, pthread_attr_t *attr)
+     {
+       /* No stack information available.  This must be for the initial
+ 	 thread.  Get the info in some magical way.  */
+-      assert (abs (thread->pid) == thread->tid);
+ 
+       /* Stack size limit.  */
+       struct rlimit rl;
+diff --git a/nptl/tst-exec5.c b/nptl/tst-exec5.c
+new file mode 100644
+index 0000000000..4327d8d41c
+--- /dev/null
++++ b/nptl/tst-exec5.c
+@@ -0,0 +1,196 @@
++/* Check if posix_spawn does not act as a cancellation entrypoint.
++   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 <errno.h>
++#include <paths.h>
++#include <pthread.h>
++#include <signal.h>
++#include <spawn.h>
++#include <stdbool.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <unistd.h>
++#include <sys/wait.h>
++
++static int do_test (void);
++#define TEST_FUNCTION do_test ()
++#include <test-skeleton.c>
++
++static pthread_barrier_t b;
++
++static pid_t pid;
++static int pipefd[2];
++
++static void *
++tf (void *arg)
++{
++  int r = pthread_barrier_wait (&b);
++  if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
++    {
++      puts ("error: pthread_barrier_wait failed");
++      exit (1);
++    }
++
++  posix_spawn_file_actions_t a;
++  if (posix_spawn_file_actions_init (&a) != 0)
++    {
++      puts ("error: spawn_file_actions_init failed");
++      exit (1);
++    }
++
++  if (posix_spawn_file_actions_adddup2 (&a, pipefd[1], STDOUT_FILENO) != 0)
++    {
++      puts ("error: spawn_file_actions_adddup2 failed");
++      exit (1);
++    }
++
++  if (posix_spawn_file_actions_addclose (&a, pipefd[0]) != 0)
++    {
++      puts ("error: spawn_file_actions_addclose");
++      exit (1);
++    }
++
++  char *argv[] = { (char *) _PATH_BSHELL, (char *) "-c", (char *) "echo $$",
++		   NULL };
++  if (posix_spawn (&pid, _PATH_BSHELL, &a, NULL, argv, NULL) != 0)
++    {
++      puts ("error: spawn failed");
++      exit (1);
++    }
++
++  return NULL;
++}
++
++
++static int
++do_test (void)
++{
++  /* The test basically pipe a 'echo $$' created by a thread with a
++     cancellation pending.  It then checks if the thread is not cancelled,
++     the process is created and if the output is the expected one.  */
++
++  if (pipe (pipefd) != 0)
++    {
++      puts ("error: pipe failed");
++      exit (1);
++    }
++
++  /* Not interested in knowing when the pipe is closed.  */
++  if (sigignore (SIGPIPE) != 0)
++    {
++      puts ("error: sigignore failed");
++      exit (1);
++    }
++
++  /* To synchronize with the thread.  */
++  if (pthread_barrier_init (&b, NULL, 2) != 0)
++    {
++      puts ("error: pthread_barrier_init failed");
++      exit (1);
++    }
++
++  pthread_t th;
++  if (pthread_create (&th, NULL, &tf, NULL) != 0)
++    {
++      puts ("error: pthread_create failed");
++      exit (1);
++    }
++
++  if (pthread_cancel (th) != 0)
++    {
++      puts ("error: pthread_cancel failed");
++      exit (1);
++    }
++
++  int r = pthread_barrier_wait (&b);
++  if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
++    {
++      puts ("error: pthread_barrier_wait");
++      exit (1);
++    }
++
++  void *retval;
++  if (pthread_join (th, &retval) != 0)
++    {
++      puts ("error: pthread_join failed\n");
++    }
++  if (retval == PTHREAD_CANCELED)
++    {
++      puts ("error: thread cancelled");
++      exit (1);
++    }
++
++  close (pipefd[1]);
++
++  /* The global 'pid' should be set by thread posix_spawn calling.  Check
++     below if it was executed correctly and with expected output.  */
++
++  char buf[64];
++  ssize_t n;
++  bool seen_pid = false;
++  while (TEMP_FAILURE_RETRY ((n = read (pipefd[0], buf, sizeof (buf)))) > 0)
++    {
++      /* We only expect to read the PID.  */
++      char *endp;
++      long int rpid = strtol (buf, &endp, 10);
++
++      if (*endp != '\n')
++	{
++	  printf ("error: didn't parse whole line: \"%s\"\n", buf);
++	  exit (1);
++	}
++      if (endp == buf)
++	{
++	  puts ("error: read empty line");
++	  exit (1);
++	}
++
++      if (rpid != pid)
++	{
++	  printf ("error: found \"%s\", expected PID %ld\n", buf,
++		 (long int) pid);
++	  exit (1);
++	}
++
++      if (seen_pid)
++	{
++	  puts ("error: found more than one PID line");
++	  exit (1);
++	}
++
++      seen_pid = true;
++    }
++
++  close (pipefd[0]);
++
++  int status;
++  int err = waitpid (pid, &status, 0);
++  if (err != pid)
++    {
++      puts ("errnor: waitpid failed");
++      exit (1);
++    }
++
++  if (!seen_pid)
++    {
++      puts ("error: didn't get PID");
++      exit (1);
++    }
++
++  return 0;
++}
+diff --git a/nptl/tst-once5.cc b/nptl/tst-once5.cc
+index 978d8271bd..513ac53f6f 100644
+--- a/nptl/tst-once5.cc
++++ b/nptl/tst-once5.cc
+@@ -75,5 +75,7 @@ do_test (void)
+   return result;
+ }
+ 
++// The test currently hangs and is XFAILed.  Reduce the timeout.
++#define TIMEOUT 1
+ #define TEST_FUNCTION do_test ()
+ #include "../test-skeleton.c"
+diff --git a/nptl_db/structs.def b/nptl_db/structs.def
+index a9b621b126..1cb6a46391 100644
+--- a/nptl_db/structs.def
++++ b/nptl_db/structs.def
+@@ -48,7 +48,6 @@ DB_STRUCT (pthread)
+ DB_STRUCT_FIELD (pthread, list)
+ DB_STRUCT_FIELD (pthread, report_events)
+ DB_STRUCT_FIELD (pthread, tid)
+-DB_STRUCT_FIELD (pthread, pid)
+ DB_STRUCT_FIELD (pthread, start_routine)
+ DB_STRUCT_FIELD (pthread, cancelhandling)
+ DB_STRUCT_FIELD (pthread, schedpolicy)
+diff --git a/nptl_db/td_ta_thr_iter.c b/nptl_db/td_ta_thr_iter.c
+index a990fed150..9e5059956b 100644
+--- a/nptl_db/td_ta_thr_iter.c
++++ b/nptl_db/td_ta_thr_iter.c
+@@ -76,48 +76,28 @@ iterate_thread_list (td_thragent_t *ta, td_thr_iter_f *callback,
+       if (ps_pdread (ta->ph, addr, copy, ta->ta_sizeof_pthread) != PS_OK)
+ 	return TD_ERR;
+ 
+-      /* Verify that this thread's pid field matches the child PID.
+-	 If its pid field is negative, it's about to do a fork or it
+-	 is the sole thread in a fork child.  */
+-      psaddr_t pid;
+-      err = DB_GET_FIELD_LOCAL (pid, ta, copy, pthread, pid, 0);
+-      if (err == TD_OK && (pid_t) (uintptr_t) pid < 0)
+-	{
+-	  if (-(pid_t) (uintptr_t) pid == match_pid)
+-	    /* It is about to do a fork, but is really still the parent PID.  */
+-	    pid = (psaddr_t) (uintptr_t) match_pid;
+-	  else
+-	    /* It must be a fork child, whose new PID is in the tid field.  */
+-	    err = DB_GET_FIELD_LOCAL (pid, ta, copy, pthread, tid, 0);
+-	}
++      err = DB_GET_FIELD_LOCAL (schedpolicy, ta, copy, pthread,
++				schedpolicy, 0);
+       if (err != TD_OK)
+ 	break;
++      err = DB_GET_FIELD_LOCAL (schedprio, ta, copy, pthread,
++				schedparam_sched_priority, 0);
++      if (err != TD_OK)
++	break;
++
++      /* Now test whether this thread matches the specified conditions.  */
+ 
+-      if ((pid_t) (uintptr_t) pid == match_pid)
++      /* Only if the priority level is as high or higher.  */
++      int descr_pri = ((uintptr_t) schedpolicy == SCHED_OTHER
++		       ? 0 : (uintptr_t) schedprio);
++      if (descr_pri >= ti_pri)
+ 	{
+-	  err = DB_GET_FIELD_LOCAL (schedpolicy, ta, copy, pthread,
+-				    schedpolicy, 0);
+-	  if (err != TD_OK)
+-	    break;
+-	  err = DB_GET_FIELD_LOCAL (schedprio, ta, copy, pthread,
+-				    schedparam_sched_priority, 0);
+-	  if (err != TD_OK)
+-	    break;
+-
+-	  /* Now test whether this thread matches the specified conditions.  */
+-
+-	  /* Only if the priority level is as high or higher.  */
+-	  int descr_pri = ((uintptr_t) schedpolicy == SCHED_OTHER
+-			   ? 0 : (uintptr_t) schedprio);
+-	  if (descr_pri >= ti_pri)
+-	    {
+-	      /* Yep, it matches.  Call the callback function.  */
+-	      td_thrhandle_t th;
+-	      th.th_ta_p = (td_thragent_t *) ta;
+-	      th.th_unique = addr;
+-	      if (callback (&th, cbdata_p) != 0)
+-		return TD_DBERR;
+-	    }
++	  /* Yep, it matches.  Call the callback function.  */
++	  td_thrhandle_t th;
++	  th.th_ta_p = (td_thragent_t *) ta;
++	  th.th_unique = addr;
++	  if (callback (&th, cbdata_p) != 0)
++	    return TD_DBERR;
+ 	}
+ 
+       /* Get the pointer to the next element.  */
+diff --git a/nptl_db/td_thr_validate.c b/nptl_db/td_thr_validate.c
+index f3c8a7bed6..9b89fecad2 100644
+--- a/nptl_db/td_thr_validate.c
++++ b/nptl_db/td_thr_validate.c
+@@ -80,28 +80,5 @@ td_thr_validate (const td_thrhandle_t *th)
+ 	err = TD_OK;
+     }
+ 
+-  if (err == TD_OK)
+-    {
+-      /* Verify that this is not a stale element in a fork child.  */
+-      pid_t match_pid = ps_getpid (th->th_ta_p->ph);
+-      psaddr_t pid;
+-      err = DB_GET_FIELD (pid, th->th_ta_p, th->th_unique, pthread, pid, 0);
+-      if (err == TD_OK && (pid_t) (uintptr_t) pid < 0)
+-	{
+-	  /* This was a thread that was about to fork, or it is the new sole
+-	     thread in a fork child.  In the latter case, its tid was stored
+-	     via CLONE_CHILD_SETTID and so is already the proper child PID.  */
+-	  if (-(pid_t) (uintptr_t) pid == match_pid)
+-	    /* It is about to do a fork, but is really still the parent PID.  */
+-	    pid = (psaddr_t) (uintptr_t) match_pid;
+-	  else
+-	    /* It must be a fork child, whose new PID is in the tid field.  */
+-	    err = DB_GET_FIELD (pid, th->th_ta_p, th->th_unique,
+-				pthread, tid, 0);
+-	}
+-      if (err == TD_OK && (pid_t) (uintptr_t) pid != match_pid)
+-	err = TD_NOTHR;
+-    }
+-
+   return err;
+ }
+diff --git a/po/de.po b/po/de.po
+index 1383e8c4a9..ca14c7e386 100644
+--- a/po/de.po
++++ b/po/de.po
+@@ -8,7 +8,7 @@ msgid ""
+ msgstr ""
+ "Project-Id-Version: GNU libc 2.22-pre1\n"
+ "POT-Creation-Date: 2015-07-31 00:10-0400\n"
+-"PO-Revision-Date: 2015-08-31 18:30+0200\n"
++"PO-Revision-Date: 2016-04-22 18:44+0200\n"
+ "Last-Translator: Jochen Hein <jochen@jochen.org>\n"
+ "Language-Team: German <translation-team-de@lists.sourceforge.net>\n"
+ "Language: de\n"
+@@ -4479,13 +4479,13 @@ msgstr ""
+ "%15s  Cache ist dauerhaft\n"
+ "%15s  Cache wird gemeinsam verwendet\n"
+ "%15Zu  vorgeschlagene Größe\n"
+-"%15Zu  Gesamtröße des Data-Pools\n"
++"%15Zu  Gesamtgröße des Data-Pools\n"
+ "%15Zu  Benutzter Speicher im Data-Pool\n"
+ "%15lu  Time to Live für positive Einträge in Sekunden\n"
+ "%15lu  Time to Live für negative Einträge in Sekunden\n"
+ "%15<PRIuMAX>  Cache-Hits bei positiven Einträgen\n"
+ "%15<PRIuMAX>  Cache-Hits bei positiven Einträgen\n"
+-"%15<PRIuMAX>  Cache-Misses bei positiven EintrÃ¤gen\n"
++"%15<PRIuMAX>  Cache-Misses bei positiven Einträgen\n"
+ "%15<PRIuMAX>  Cache-Misses bei negativen Einträgen\n"
+ "%15lu%% Cache-Hit Verhältnis\n"
+ "%15zu  aktuelle Anzahl der Werte im Cache\n"
+diff --git a/po/fi.po b/po/fi.po
+index 17cb3e3e1d..8a2ab8358c 100644
+--- a/po/fi.po
++++ b/po/fi.po
+@@ -24,16 +24,16 @@
+ #
+ msgid ""
+ msgstr ""
+-"Project-Id-Version: libc 2.21-pre1\n"
++"Project-Id-Version: libc 2.22-pre1\n"
+ "POT-Creation-Date: 2015-07-31 00:10-0400\n"
+-"PO-Revision-Date: 2015-07-28 20:29+0300\n"
++"PO-Revision-Date: 2016-05-26 21:14+0300\n"
+ "Last-Translator: Lauri Nurmi <lanurmi@iki.fi>\n"
+ "Language-Team: Finnish <translation-team-fi@lists.sourceforge.net>\n"
+ "Language: fi\n"
+ "MIME-Version: 1.0\n"
+ "Content-Type: text/plain; charset=UTF-8\n"
+ "Content-Transfer-Encoding: 8bit\n"
+-"X-Generator: Poedit 1.8.3\n"
++"X-Generator: Poedit 1.8.7\n"
+ "Plural-Forms: nplurals=2; plural=(n != 1);\n"
+ 
+ #: argp/argp-help.c:227
+@@ -126,7 +126,7 @@ msgid "%s%s%s:%u: %s%sUnexpected error: %s.\n"
+ msgstr "%s%s%s:%u: %s%sOdottamaton virhe: %s.\n"
+ 
+ #: assert/assert.c:101
+-#, fuzzy, c-format
++#, c-format
+ msgid ""
+ "%s%s%s:%u: %s%sAssertion `%s' failed.\n"
+ "%n"
+@@ -169,12 +169,12 @@ msgstr ""
+ #: malloc/memusagestat.c:563 nss/getent.c:973 nss/makedb.c:369
+ #: posix/getconf.c:486 sunrpc/rpcinfo.c:691
+ #: sysdeps/unix/sysv/linux/lddlibc4.c:61
+-#, fuzzy, c-format
++#, c-format
+ msgid ""
+ "For bug reporting instructions, please see:\n"
+ "%s.\n"
+ msgstr ""
+-"Ohjeet ohjelmistovioista ilmoittamiseen ovat osoitteessa\n"
++"Katso ohjeet vikailmoitusten tekemiseen osoitteesta:\n"
+ "%s.\n"
+ 
+ #: catgets/gencat.c:245 debug/pcprofiledump.c:225 debug/xtrace.sh:64
+@@ -321,9 +321,8 @@ msgstr "Käyttö: xtrace [VALITSIN]... OHJELMA [OHJELMANVALITSIN]...\\n"
+ 
+ #: debug/xtrace.sh:32 elf/sotruss.sh:56 elf/sotruss.sh:67 elf/sotruss.sh:135
+ #: malloc/memusage.sh:26
+-#, fuzzy
+ msgid "Try \\`%s --help' or \\`%s --usage' for more information.\\n"
+-msgstr "Kokeile ???%s --help??? tai ???%s --usage??? saadaksesi lisää tietoa.\n"
++msgstr "Kokeile ???%s --help??? tai ???%s --usage??? saadaksesi lisää tietoa.\\n"
+ 
+ #: debug/xtrace.sh:38
+ #, fuzzy
+@@ -594,9 +593,8 @@ msgid "cannot enable executable stack as shared object requires"
+ msgstr "jaettua objektikahvaa ei voi luoda"
+ 
+ #: elf/dl-load.c:1339
+-#, fuzzy
+ msgid "cannot close file descriptor"
+-msgstr "tiedostoa %s ei voi sulkea"
++msgstr "tiedostokahvaa ei voi sulkea"
+ 
+ #: elf/dl-load.c:1568
+ msgid "file too short"
+@@ -796,9 +794,8 @@ msgid "Format to use: new, old or compat (default)"
+ msgstr "Käytettävä muoto: ???new???, ???old??? tai ???compat??? (oletus)"
+ 
+ #: elf/ldconfig.c:151
+-#, fuzzy
+ msgid "Ignore auxiliary cache file"
+-msgstr "Käytä CACHEa välimuistitiedostona"
++msgstr "Jätä huomiotta apuvälimuistitiedosto"
+ 
+ #: elf/ldconfig.c:159
+ msgid "Configure Dynamic Linker Run Time Bindings."
+@@ -1087,9 +1084,9 @@ msgid "invalid process ID '%s'"
+ msgstr "virheellinen prosessi-ID ???%s???"
+ 
+ #: elf/pldd.c:120
+-#, fuzzy, c-format
++#, c-format
+ msgid "cannot open %s"
+-msgstr "laitetta %s ei voi avata"
++msgstr "tiedostoa %s ei voi avata"
+ 
+ #: elf/pldd.c:152
+ #, fuzzy, c-format
+@@ -1102,24 +1099,24 @@ msgid "cannot prepare reading %s/task"
+ msgstr "ei voi avata laitetta %s lukutilaan"
+ 
+ #: elf/pldd.c:168
+-#, fuzzy, c-format
++#, c-format
+ msgid "invalid thread ID '%s'"
+-msgstr "virheellinen prosessi-ID ???%s???"
++msgstr "virheellinen säie-ID ???%s???"
+ 
+ #: elf/pldd.c:179
+-#, fuzzy, c-format
++#, c-format
+ msgid "cannot attach to process %lu"
+-msgstr "tiedostoa ???%s??? ei voi avata"
++msgstr "ei voida kiinnittyä prosessiin %lu"
+ 
+ #: elf/pldd.c:294
+ #, c-format
+ msgid "cannot get information about process %lu"
+-msgstr ""
++msgstr "tietojen saaminen prosessista %lu ei onnistu"
+ 
+ #: elf/pldd.c:307
+-#, fuzzy, c-format
++#, c-format
+ msgid "process %lu is no ELF program"
+-msgstr "ohjelma %lu ei ole käytettävissä\n"
++msgstr "prosessi %lu ei ole ELF-ohjelma"
+ 
+ #: elf/readelflib.c:34
+ #, c-format
+@@ -1203,7 +1200,7 @@ msgstr "%s kohde ei saa olla hakemisto\n"
+ #: elf/sln.c:184
+ #, c-format
+ msgid "%s: failed to remove the old destination\n"
+-msgstr ""
++msgstr "%s: vanhan kohteen poistaminen epäonnistui\n"
+ 
+ #: elf/sln.c:192
+ #, c-format
+@@ -1237,9 +1234,8 @@ msgid "Mandatory arguments to long options are also mandatory for any correspond
+ msgstr "Pakolliset argumentit pitkille valitsimille ovat pakollisia kaikille vastaaville lyhyille valitsimille.\\n"
+ 
+ #: elf/sotruss.sh:55
+-#, fuzzy
+ msgid "%s: option requires an argument -- '%s'\\n"
+-msgstr "%s: valitsin ???%s??? vaatii argumentin\n"
++msgstr "%s: valitsin vaatii argumentin -- ???%c???\\n"
+ 
+ #: elf/sotruss.sh:61
+ msgid "%s: option is ambiguous; possibilities:"
+@@ -1507,7 +1503,6 @@ msgid "unknown iconv() error %d"
+ msgstr "tuntematon iconv()-virhe %d"
+ 
+ #: iconv/iconv_prog.c:791
+-#, fuzzy
+ msgid ""
+ "The following list contains all the coded character sets known.  This does\n"
+ "not necessarily mean that all combinations of these names can be used for\n"
+@@ -1516,9 +1511,9 @@ msgid ""
+ "\n"
+ "  "
+ msgstr ""
+-"Seuraavassa listassa ovat kaikki tunnetut koodatut merkistöt. Se ei\n"
++"Seuraavassa listassa ovat kaikki tunnetut koodatut merkistöt. Tämä ei\n"
+ "kuitenkaan välttämättä tarkoita sitä, että kaikkia näiden nimien\n"
+-"yhdistelmiä voidaan käyttää FROM- ja TO-komentoriviparametreina. Yksi\n"
++"yhdistelmiä voisi käyttää FROM- ja TO-komentoriviparametreina. Yksi\n"
+ "koodattu merkistö voi olla listalla useilla eri nimillä (aliaksilla).\n"
+ "\n"
+ "  "
+@@ -2733,14 +2728,12 @@ msgid "locale.alias file to consult when making archive"
+ msgstr "Arkistoa luotaessa käytettävä locale.alias-tiedosto"
+ 
+ #: locale/programs/localedef.c:150
+-#, fuzzy
+ msgid "Generate little-endian output"
+-msgstr "Tuota little-endian-koodia"
++msgstr "Tuota little-endian-muotoa"
+ 
+ #: locale/programs/localedef.c:152
+-#, fuzzy
+ msgid "Generate big-endian output"
+-msgstr "Tuota big-endian-koodia"
++msgstr "Tuota big-endian-muotoa"
+ 
+ #: locale/programs/localedef.c:157
+ msgid "Compile locale specification"
+@@ -4275,10 +4268,9 @@ msgid ""
+ msgstr ""
+ 
+ #: nscd/nscd.c:635
+-#, fuzzy, c-format
+-#| msgid "lstat failed"
++#, c-format
+ msgid "'wait' failed\n"
+-msgstr "tiedoston tilan luku epäonnistui"
++msgstr "???wait??? epäonnistui\n"
+ 
+ #: nscd/nscd.c:642
+ #, c-format
+@@ -4670,9 +4662,9 @@ msgid "cannot create temporary file"
+ msgstr "tilapäistä tiedostoa ei voi luoda"
+ 
+ #: nss/makedb.c:304
+-#, fuzzy, c-format
++#, c-format
+ msgid "cannot stat newly created file"
+-msgstr "tiedoston ???%s??? tilaa ei voi lukea: %s"
++msgstr "juuri luodun tiedoston tilaa ei voi lukea"
+ 
+ #: nss/makedb.c:315
+ #, c-format
+@@ -4680,9 +4672,9 @@ msgid "cannot rename temporary file"
+ msgstr "tilapäistä tiedostoa ei voi nimetä uudelleen"
+ 
+ #: nss/makedb.c:531 nss/makedb.c:554
+-#, fuzzy, c-format
++#, c-format
+ msgid "cannot create search tree"
+-msgstr "hakupolulle ei voi luoda välimuistia"
++msgstr "hakupuuta ei voi luoda"
+ 
+ #: nss/makedb.c:560
+ msgid "duplicate key"
+@@ -4699,9 +4691,9 @@ msgid "failed to write new database file"
+ msgstr "uuden tietokantatiedoston kirjoittaminen epäonnistui"
+ 
+ #: nss/makedb.c:812
+-#, fuzzy, c-format
++#, c-format
+ msgid "cannot stat database file"
+-msgstr "tiedoston ???%s??? tilaa ei voi lukea: %s"
++msgstr "tietokantatiedoston tilaa ei voi lukea"
+ 
+ #: nss/makedb.c:817
+ #, fuzzy, c-format
+@@ -4709,9 +4701,9 @@ msgid "cannot map database file"
+ msgstr "Karttatietokannassa ei ole enempää tietueita"
+ 
+ #: nss/makedb.c:820
+-#, fuzzy, c-format
++#, c-format
+ msgid "file not a database file"
+-msgstr "luettaessa profilointidatatiedoston tilaa"
++msgstr "tiedosto ei ole tietokantatiedosto"
+ 
+ #: nss/makedb.c:871
+ #, fuzzy, c-format
+@@ -4726,7 +4718,7 @@ msgstr "Käyttö: %s [-v määrittely] muuttujanimi [polku]\n"
+ #: posix/getconf.c:403
+ #, c-format
+ msgid "       %s -a [pathname]\n"
+-msgstr ""
++msgstr "       %s -a [polku]\n"
+ 
+ #: posix/getconf.c:479
+ #, c-format
+@@ -5094,11 +5086,11 @@ msgstr "Laitetta irrotettu"
+ 
+ #: stdio-common/psiginfo.c:139
+ msgid "Signal sent by kill()"
+-msgstr ""
++msgstr "Signaalin lähetti kill()"
+ 
+ #: stdio-common/psiginfo.c:142
+ msgid "Signal sent by sigqueue()"
+-msgstr ""
++msgstr "Signaalin lähetti sigqueue()"
+ 
+ #: stdio-common/psiginfo.c:145
+ msgid "Signal generated by the expiration of a timer"
+@@ -5114,7 +5106,7 @@ msgstr ""
+ 
+ #: stdio-common/psiginfo.c:157
+ msgid "Signal sent by tkill()"
+-msgstr ""
++msgstr "Signaalin lähetti tkill()"
+ 
+ #: stdio-common/psiginfo.c:162
+ msgid "Signal generated by the completion of an asynchronous name lookup request"
+@@ -5296,9 +5288,8 @@ msgid "Failed (unspecified error)"
+ msgstr "Epäonnistui (määrittelemätön virhe)"
+ 
+ #: sunrpc/clnt_raw.c:115
+-#, fuzzy
+ msgid "clnt_raw.c: fatal header serialization error"
+-msgstr "clnt_raw.c: vakava otsikon serialisointivirhe"
++msgstr "clnt_raw.c: vakava otsikon sarjallistamisvirhe"
+ 
+ #: sunrpc/pm_getmaps.c:77
+ msgid "pmap_getmaps.c: rpc problem"
+@@ -6825,9 +6816,8 @@ msgid "Interrupted by a signal"
+ msgstr "Signaalin keskeyttämä"
+ 
+ #: sysdeps/posix/gai_strerror-strs.h:17
+-#, fuzzy
+ msgid "Parameter string not correctly encoded"
+-msgstr "Parametrimerkkijono on väärin koodattu"
++msgstr "Parametrimerkkijono ei ole koodattu oikein"
+ 
+ #: sysdeps/unix/sysv/linux/i386/readelflib.c:65
+ #, c-format
+diff --git a/po/sv.po b/po/sv.po
+index 49d1f23904..e046577b08 100644
+--- a/po/sv.po
++++ b/po/sv.po
+@@ -1,13 +1,17 @@
+ # GNU libc message catalog for Swedish
+-# Copyright © 1996, 1998, 2001, 2002, 2003, 2006, 2008, 2009, 2011, 2012, 2013, 2014, 2015 Free Software Foundation, Inc.
++# Copyright © 1996, 1998, 2001, 2002, 2003, 2006, 2008, 2009, 2011, 2012, 2013, 2014, 2015, 2016 Free Software Foundation, Inc.
+ # This file is distributed under the same license as the glibc package.
+-# Jan Djärv <jan.h.d@swipnet.se>, 1996, 1998, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2011, 2012, 2013, 2014, 2015
++#
++# Jan Djärv <jan.h.d@swipnet.se>, 1996, 1998, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2011, 2012, 2013, 2014, 2015.
++# Göran Uddeborg <goeran@uddeborg.se>, 2016.
++#
++# $Revision: 1.3 $
+ msgid ""
+ msgstr ""
+-"Project-Id-Version: libc 2.21-pre1\n"
++"Project-Id-Version: libc 2.22-pre1\n"
+ "POT-Creation-Date: 2015-07-31 00:10-0400\n"
+-"PO-Revision-Date: 2015-01-24 10:35+0100\n"
+-"Last-Translator: Jan Djärv <jan.h.d@swipnet.se>\n"
++"PO-Revision-Date: 2016-08-02 17:17+0200\n"
++"Last-Translator: Göran Uddeborg <goeran@uddeborg.se>\n"
+ "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
+ "Language: sv\n"
+ "MIME-Version: 1.0\n"
+@@ -48,7 +52,7 @@ msgstr " [FLAGGA...]"
+ #: argp/argp-help.c:1643
+ #, c-format
+ msgid "Try `%s --help' or `%s --usage' for more information.\n"
+-msgstr "Försök med \"%s --help\" eller \"%s --usage\" för mer information\n"
++msgstr "Försök med ???%s --help??? eller ???%s --usage??? för mer information.\n"
+ 
+ #: argp/argp-help.c:1671
+ #, c-format
+@@ -304,11 +308,11 @@ msgstr "Användning: xtrace [FLAGGA]... PROGRAM [PROGRAMFLAGGA}...\\n"
+ #: debug/xtrace.sh:32 elf/sotruss.sh:56 elf/sotruss.sh:67 elf/sotruss.sh:135
+ #: malloc/memusage.sh:26
+ msgid "Try \\`%s --help' or \\`%s --usage' for more information.\\n"
+-msgstr "Försök med \\\"%s --help\\\" eller \\\"%s --usage\\\" för mer information\\n"
++msgstr "Försök med ???%s --help??? eller ???%s --usage??? för mer information\\n"
+ 
+ #: debug/xtrace.sh:38
+ msgid "%s: option '%s' requires an argument.\\n"
+-msgstr "%s: flaggan \\\"%s\\\" kräver ett argument\\n"
++msgstr "%s: flaggan ???%s??? kräver ett argument.\\n"
+ 
+ #: debug/xtrace.sh:45
+ msgid ""
+@@ -332,19 +336,17 @@ msgstr ""
+ "      --usage             Visa en kort hjälptext\n"
+ "   -V,--version           Visa versionsinformation och avsluta\n"
+ "\n"
+-"Obligatoriska argument för långa flaggor är obligatoriska  även för\n"
++"Obligatoriska argument för långa flaggor är obligatoriska även för\n"
+ "motsvarande korta.\n"
+ 
+ #: debug/xtrace.sh:57 elf/ldd.bash.in:55 elf/sotruss.sh:49
+ #: malloc/memusage.sh:64
+ msgid "For bug reporting instructions, please see:\\\\n%s.\\\\n"
+-msgstr ""
+-"För felrapporteringsinstruktioner, se:\\\\n%s.\\\\n\n"
+-"Rapportera fel eller synpunkter på översättningen till <tp-sv@listor.tp-sv.se>.\\\\n"
++msgstr "För felrapporteringsinstruktioner, se:\\\\n%s.\\\\nRapportera fel eller synpunkter på översättningen till:\\\\n<tp-sv@listor.tp-sv.se>.\\\\n"
+ 
+ #: debug/xtrace.sh:125
+ msgid "xtrace: unrecognized option \\`$1'\\n"
+-msgstr "xtrace: okänd flagga \"$1\"\\n"
++msgstr "xtrace: okänd flagga ???$1???\\n"
+ 
+ #: debug/xtrace.sh:138
+ msgid "No program name given\\n"
+@@ -353,12 +355,12 @@ msgstr "Inget programnamn givet\\n"
+ #: debug/xtrace.sh:146
+ #, sh-format
+ msgid "executable \\`$program' not found\\n"
+-msgstr "program \"$program\" hittades inte\\n"
++msgstr "program ???$program??? hittades inte\\n"
+ 
+ #: debug/xtrace.sh:150
+ #, sh-format
+ msgid "\\`$program' is no executable\\n"
+-msgstr "\"$program\" är inte en körbar binär\\n"
++msgstr "???$program??? är inte en körbar binär\\n"
+ 
+ #: dlfcn/dlinfo.c:63
+ msgid "RTLD_SELF used in code not dynamically loaded"
+@@ -396,7 +398,7 @@ msgstr ", OS ABI: %s %d.%d.%d"
+ #: elf/cache.c:157 elf/ldconfig.c:1340
+ #, c-format
+ msgid "Can't open cache file %s\n"
+-msgstr "Kan inte öppna cache-fil \"%s\"\n"
++msgstr "Kan inte öppna cache-filen %s\n"
+ 
+ #: elf/cache.c:171
+ #, c-format
+@@ -416,7 +418,7 @@ msgstr "%d bibliotek hittades i cache \"%s\"\n"
+ #: elf/cache.c:426
+ #, c-format
+ msgid "Can't create temporary cache file %s"
+-msgstr "Kan inte skapa temporär cache-fil \"%s\""
++msgstr "Kan inte skapa en temporär cache-fil %s"
+ 
+ #: elf/cache.c:434 elf/cache.c:444 elf/cache.c:448 elf/cache.c:453
+ #, c-format
+@@ -829,7 +831,7 @@ msgstr "Kan inte ta status (lstat) på %s"
+ #: elf/ldconfig.c:609
+ #, c-format
+ msgid "Ignored file %s since it is not a regular file."
+-msgstr "Ignorerar fil %s eftersom den inte är en vanlig fil"
++msgstr "Ignorerar fil %s eftersom den inte är en vanlig fil."
+ 
+ #: elf/ldconfig.c:618
+ #, c-format
+@@ -951,7 +953,7 @@ msgstr ""
+ 
+ #: elf/ldd.bash.in:80
+ msgid "ldd: option \\`$1' is ambiguous"
+-msgstr "ldd: flaggan \"$1\" är tvetydig"
++msgstr "ldd: flaggan ???$1??? är tvetydig"
+ 
+ #: elf/ldd.bash.in:87
+ msgid "unrecognized option"
+@@ -959,7 +961,7 @@ msgstr "okänd flagga"
+ 
+ #: elf/ldd.bash.in:88 elf/ldd.bash.in:125
+ msgid "Try \\`ldd --help' for more information."
+-msgstr "Försök med \"ldd --help\" för mer information"
++msgstr "Försök med \"ldd --help\" för mer information."
+ 
+ #: elf/ldd.bash.in:124
+ msgid "missing file arguments"
+@@ -1028,10 +1030,9 @@ msgid "cannot read object name"
+ msgstr "kan inte läsa objektnamn"
+ 
+ #: elf/pldd-xx.c:219
+-#, fuzzy, c-format
+-#| msgid "cannot allocate memory for program header"
++#, c-format
+ msgid "cannot allocate buffer for object name"
+-msgstr "kan inte allokera minne för programhuvud"
++msgstr "kan inte allokera en buffert för objektnamn"
+ 
+ #: elf/pldd.c:64
+ msgid "List dynamic shared objects loaded into process."
+@@ -1212,11 +1213,11 @@ msgstr ""
+ 
+ #: elf/sotruss.sh:46
+ msgid "Mandatory arguments to long options are also mandatory for any corresponding\\nshort options.\\n"
+-msgstr "Obligatoriska respektive valfria argument för långa flaggor är obligatoriska respektive\\nvalfria även för korta.\\n"
++msgstr "Obligatoriska respektive valfria argument för långa flaggor är obligatoriska\\nrespektive valfria även för korta.\\n"
+ 
+ #: elf/sotruss.sh:55
+ msgid "%s: option requires an argument -- '%s'\\n"
+-msgstr "%s: flaggan kräver ett argument -- \\\"%s\\\"\\n"
++msgstr "%s: flaggan kräver ett argument ??? ???%s???\\n"
+ 
+ #: elf/sotruss.sh:61
+ msgid "%s: option is ambiguous; possibilities:"
+@@ -1240,7 +1241,7 @@ msgstr ""
+ 
+ #: elf/sotruss.sh:134
+ msgid "%s: unrecognized option '%c%s'\\n"
+-msgstr "%s: okänd flagga \\\"%c%s\\\"\\n"
++msgstr "%s: okänd flagga ???%c%s???\\n"
+ 
+ #: elf/sprof.c:77
+ msgid "Output selection:"
+@@ -1260,7 +1261,7 @@ msgstr "generera anropsgraf"
+ 
+ #: elf/sprof.c:89
+ msgid "Read and display shared object profiling data."
+-msgstr "Läs och visa profildata för delat objekt"
++msgstr "Läs och visa profildata för delat objekt."
+ 
+ #: elf/sprof.c:94
+ msgid "SHOBJ [PROFDATA]"
+@@ -1622,7 +1623,7 @@ msgstr "Fel: .netrc kan läsas av andra."
+ 
+ #: inet/ruserpass.c:185
+ msgid "Remove password or make file unreadable by others."
+-msgstr "Ta bort lösenord eller gör filen oläsbar för andra"
++msgstr "Ta bort lösenord eller gör filen oläsbar för andra."
+ 
+ #: inet/ruserpass.c:277
+ #, c-format
+@@ -2182,12 +2183,12 @@ msgstr "Inget namn definierat i teckenuppsättning"
+ #: locale/programs/ld-ctype.c:479
+ #, c-format
+ msgid "character L'\\u%0*x' in class `%s' must be in class `%s'"
+-msgstr "tecken L\"\\u%0*x\" i klass \"%s\" måste vara i klass \"%s\""
++msgstr "tecken L'\\u%0*x' i klassen ???%s??? måste vara i klassen ???%s???"
+ 
+ #: locale/programs/ld-ctype.c:494
+ #, c-format
+ msgid "character L'\\u%0*x' in class `%s' must not be in class `%s'"
+-msgstr "tecken L\"\\u%0*x\" i klass \"%s\" får inte vara i klass \"%s\""
++msgstr "tecken L'\\u%0*x' i klassen ???%s??? får inte vara i klassen ???%s???"
+ 
+ #: locale/programs/ld-ctype.c:508 locale/programs/ld-ctype.c:566
+ #, c-format
+@@ -2611,7 +2612,7 @@ msgstr "Skriv mer information"
+ 
+ #: locale/programs/locale.c:85
+ msgid "Get locale-specific information."
+-msgstr "Hämta lokalspecifik information"
++msgstr "Hämta lokalspecifik information."
+ 
+ #: locale/programs/locale.c:88
+ msgid ""
+@@ -3022,7 +3023,7 @@ msgstr "felaktig mcheck_status, biblioteket är felaktigt\n"
+ 
+ #: malloc/memusage.sh:32
+ msgid "%s: option '%s' requires an argument\\n"
+-msgstr "%s: flaggan \\\"%s\\\" kräver ett argument\\n"
++msgstr "%s: flaggan ???%s??? kräver ett argument\\n"
+ 
+ #: malloc/memusage.sh:38
+ msgid ""
+@@ -3091,11 +3092,11 @@ msgstr ""
+ 
+ #: malloc/memusage.sh:191
+ msgid "memusage: option \\`${1##*=}' is ambiguous"
+-msgstr "memusage: flaggan \"${1##*=}\" är tvetydig"
++msgstr "memusage: flaggan ???${1##*=}??? är tvetydig"
+ 
+ #: malloc/memusage.sh:200
+ msgid "memusage: unrecognized option \\`$1'"
+-msgstr "memusage: okänd flagga \"$1\""
++msgstr "memusage: okänd flagga ???$1???"
+ 
+ #: malloc/memusage.sh:213
+ msgid "No program name given"
+@@ -3341,7 +3342,7 @@ msgstr "Kan inte skapa process hos server"
+ 
+ #: nis/nis_error.h:48
+ msgid "Master server busy, full dump rescheduled."
+-msgstr "Huvudserver är upptagen, full dump åter schemalagd"
++msgstr "Huvudserver är upptagen, full dump åter schemalagd."
+ 
+ #: nis/nis_local_names.c:121
+ #, c-format
+@@ -3511,7 +3512,7 @@ msgstr "\t\tRättigheter   : "
+ 
+ #: nis/nis_print.c:290
+ msgid "Linked Object Type : "
+-msgstr "Länkad objekttyp: "
++msgstr "Länkad objekttyp   : "
+ 
+ #: nis/nis_print.c:292
+ #, c-format
+@@ -3802,15 +3803,14 @@ msgid " (first)"
+ msgstr " (första)"
+ 
+ #: nscd/cache.c:288
+-#, fuzzy, c-format
+-#| msgid "cannot stat() file `%s': %s"
++#, c-format
+ msgid "checking for monitored file `%s': %s"
+-msgstr "kan inte ta status på fil \"%s\": %s"
++msgstr "kontrollerar den övervakade filen ???%s???: %s"
+ 
+ #: nscd/cache.c:298
+ #, c-format
+ msgid "monitored file `%s` changed (mtime)"
+-msgstr ""
++msgstr "den övervakade filen ???%s??? ändrades (mtime)"
+ 
+ #: nscd/cache.c:341
+ #, c-format
+@@ -3906,34 +3906,32 @@ msgstr "kan inte få uttag (socket) att acceptera förbindelser: %s"
+ #: nscd/connections.c:973
+ #, c-format
+ msgid "disabled inotify-based monitoring for file `%s': %s"
+-msgstr ""
++msgstr "avaktiverade inotify-baserad övervakning för filen ???%s???: %s"
+ 
+ #: nscd/connections.c:977
+ #, c-format
+ msgid "monitoring file `%s` (%d)"
+-msgstr ""
++msgstr "övervakar filen ???%s??? (%d)"
+ 
+ #: nscd/connections.c:990
+ #, c-format
+ msgid "disabled inotify-based monitoring for directory `%s': %s"
+-msgstr ""
++msgstr "avaktiverade inotify-baserad övervakning av katalogen ???%s???: %s"
+ 
+ #: nscd/connections.c:994
+-#, fuzzy, c-format
+-#| msgid "Can't open directory %s"
++#, c-format
+ msgid "monitoring directory `%s` (%d)"
+-msgstr "Kan inte öppna katalog %s"
++msgstr "övervakar katalogen ???%s??? (%d)"
+ 
+ #: nscd/connections.c:1022
+-#, fuzzy, c-format
+-#| msgid "register trace file %s for database %s"
++#, c-format
+ msgid "monitoring file %s for database %s"
+-msgstr "registrera spårningsfil %s för databas %s"
++msgstr "övervakar filen %s för databas %s"
+ 
+ #: nscd/connections.c:1032
+ #, c-format
+ msgid "stat failed for file `%s'; will try again later: %s"
+-msgstr ""
++msgstr "stat misslyckades för filen ???%s???; kommer försöka igen senare: %s"
+ 
+ #: nscd/connections.c:1151
+ #, c-format
+@@ -4032,44 +4030,42 @@ msgstr "handle_request: begäran mottagen (Version = %d)"
+ #: nscd/connections.c:1963
+ #, c-format
+ msgid "ignored inotify event for `%s` (file exists)"
+-msgstr ""
++msgstr "ignorerade inotify-händelse för ???%s??? (filen finns)"
+ 
+ #: nscd/connections.c:1968
+ #, c-format
+ msgid "monitored file `%s` was %s, removing watch"
+-msgstr ""
++msgstr "den övervakade filen ???%s??? var %s, tar bort vakten"
+ 
+ #: nscd/connections.c:1976 nscd/connections.c:2018
+ #, c-format
+ msgid "failed to remove file watch `%s`: %s"
+-msgstr ""
++msgstr "misslyckades att ta bort filvakt ???%s???: %s"
+ 
+ #: nscd/connections.c:1991
+ #, c-format
+ msgid "monitored file `%s` was written to"
+-msgstr ""
++msgstr "den övervakade filen ???%s??? skrevs till"
+ 
+ #: nscd/connections.c:2015
+ #, c-format
+ msgid "monitored parent directory `%s` was %s, removing watch on `%s`"
+-msgstr ""
++msgstr "den övervakade föräldrakatalogen ???%s??? var %s, tar bort vakten av ???%s???"
+ 
+ #: nscd/connections.c:2041
+ #, c-format
+ msgid "monitored file `%s` was %s, adding watch"
+-msgstr ""
++msgstr "den övervakade filen ???%s??? var %s, lägger till vakt"
+ 
+ #: nscd/connections.c:2053
+-#, fuzzy, c-format
+-#| msgid "failed to load shared object `%s'"
++#, c-format
+ msgid "failed to add file watch `%s`: %s"
+-msgstr "misslyckades med att ladda delat objekt \"%s\""
++msgstr "misslyckades med att lägga till filvakt ???%s???: %s"
+ 
+ #: nscd/connections.c:2247 nscd/connections.c:2428
+-#, fuzzy, c-format
+-#| msgid "disabled inotify after read error %d"
++#, c-format
+ msgid "disabled inotify-based monitoring after read error %d"
+-msgstr "inaktiverade inotify efter läsfel %d"
++msgstr "avaktiverade inotify-baserad övervakning efter läsfel %d"
+ 
+ #: nscd/connections.c:2543
+ msgid "could not initialize conditional variable"
+@@ -4199,7 +4195,7 @@ msgstr "Använd separat cache för varje användare"
+ 
+ #: nscd/nscd.c:122
+ msgid "Name Service Cache Daemon."
+-msgstr "Namntjänst cache-demon"
++msgstr "Cache-demon för namntjänsten."
+ 
+ #: nscd/nscd.c:155 nss/getent.c:1007 nss/makedb.c:206
+ #, c-format
+@@ -4531,11 +4527,11 @@ msgstr "Access Vector Cache (AVC) startad"
+ 
+ #: nscd/selinux.c:368
+ msgid "Error querying policy for undefined object classes or permissions."
+-msgstr "Fel när policy för odefinierade objektklasser eller rättigheter hämtades"
++msgstr "Fel när policy för odefinierade objektklasser eller rättigheter hämtades."
+ 
+ #: nscd/selinux.c:375
+ msgid "Error getting security class for nscd."
+-msgstr "Fel när säkerhetsklass för nscd hämtades"
++msgstr "Fel när säkerhetsklass för nscd hämtades."
+ 
+ #: nscd/selinux.c:380
+ #, c-format
+@@ -4609,7 +4605,7 @@ msgstr "inaktivera DIN-kodning"
+ 
+ #: nss/getent.c:64
+ msgid "Get entries from administrative database."
+-msgstr "Hämta poster från den administrativa databasen"
++msgstr "Hämta poster från den administrativa databasen."
+ 
+ #: nss/getent.c:148 nss/getent.c:477 nss/getent.c:522
+ #, c-format
+@@ -4652,7 +4648,7 @@ msgstr "Genererad rad som inte ingår i iterationen"
+ 
+ #: nss/makedb.c:131
+ msgid "Create simple database from textual input."
+-msgstr "Skapa en enkel databas från textuell indata"
++msgstr "Skapa en enkel databas från textuell indata."
+ 
+ #: nss/makedb.c:134
+ msgid ""
+@@ -5412,7 +5408,7 @@ msgstr "Kan inte ange netid-flaggan utan TIRPC!\n"
+ #: sunrpc/rpc_main.c:1374
+ #, c-format
+ msgid "Cannot use table flags with newstyle!\n"
+-msgstr "Kan inte ange tabellflaggor med ny stil\n"
++msgstr "Kan inte ange tabellflaggor med ny stil!\n"
+ 
+ #: sunrpc/rpc_main.c:1393
+ #, c-format
+@@ -7270,18 +7266,9 @@ msgstr "tidszonsförkortning skiljer sig från POSIX-standarden"
+ 
+ #: timezone/zic.c:2789
+ msgid "too many, or too long, time zone abbreviations"
+-msgstr "för många eller för långa tidszonförkortningar"
++msgstr "för många eller för långa tidszonsförkortningar"
+ 
+ #: timezone/zic.c:2829
+ #, c-format
+ msgid "%s: Can't create directory %s: %s\n"
+ msgstr "%s: Kan inte skapa katalog %s: %s\n"
+-
+-#~ msgid "cannot load any more object with static TLS"
+-#~ msgstr "kan inte ladda fler objekt med statiskt TLS"
+-
+-#~ msgid "%s: no PLTREL found in object %s\n"
+-#~ msgstr "%s: hittade inga PLTREL i objekt %s\n"
+-
+-#~ msgid "cannot create internal descriptors"
+-#~ msgstr "kan inte skapa interna deskriptorer"
+diff --git a/posix/Makefile b/posix/Makefile
+index 5b0e298f75..82a4020c76 100644
+--- a/posix/Makefile
++++ b/posix/Makefile
+@@ -43,7 +43,7 @@ routines :=								      \
+ 	getpgid setpgid getpgrp bsd-getpgrp setpgrp getsid setsid	      \
+ 	getresuid getresgid setresuid setresgid				      \
+ 	pathconf sysconf fpathconf					      \
+-	glob glob64 fnmatch regex					      \
++	glob glob64 globfree globfree64 glob_pattern_p fnmatch regex	      \
+ 	confstr								      \
+ 	getopt getopt1 getopt_init					      \
+ 	sched_setp sched_getp sched_sets sched_gets sched_yield sched_primax  \
+@@ -90,7 +90,7 @@ tests		:= tstgetopt testfnm runtests runptests	     \
+ 		   bug-getopt5 tst-getopt_long1 bug-regex34 bug-regex35 \
+ 		   tst-pathconf tst-getaddrinfo4 tst-rxspencer-no-utf8 \
+ 		   tst-fnmatch3 bug-regex36 tst-getaddrinfo5 \
+-		   tst-posix_spawn-fd
++		   tst-posix_spawn-fd tst-glob-tilde
+ xtests		:= bug-ga2
+ ifeq (yes,$(build-shared))
+ test-srcs	:= globtest
+@@ -133,7 +133,8 @@ tests-special += $(objpfx)bug-regex2-mem.out $(objpfx)bug-regex14-mem.out \
+ 		 $(objpfx)tst-rxspencer-no-utf8-mem.out $(objpfx)tst-pcre-mem.out \
+ 		 $(objpfx)tst-boost-mem.out $(objpfx)tst-getconf.out \
+ 		 $(objpfx)bug-glob2-mem.out $(objpfx)tst-vfork3-mem.out \
+-		 $(objpfx)tst-fnmatch-mem.out $(objpfx)bug-regex36-mem.out
++		 $(objpfx)tst-fnmatch-mem.out $(objpfx)bug-regex36-mem.out \
++		 $(objpfx)tst-glob-tilde-mem.out
+ xtests-special += $(objpfx)bug-ga2-mem.out
+ endif
+ 
+@@ -340,6 +341,12 @@ $(objpfx)bug-glob2-mem.out: $(objpfx)bug-glob2.out
+ 	$(common-objpfx)malloc/mtrace $(objpfx)bug-glob2.mtrace > $@; \
+ 	$(evaluate-test)
+ 
++tst-glob-tilde-ENV = MALLOC_TRACE=$(objpfx)tst-glob-tilde.mtrace
++
++$(objpfx)tst-glob-tilde-mem.out: $(objpfx)tst-glob-tilde.out
++	$(common-objpfx)malloc/mtrace $(objpfx)tst-glob-tilde.mtrace > $@; \
++	$(evaluate-test)
++
+ $(inst_libexecdir)/getconf: $(inst_bindir)/getconf \
+ 			    $(objpfx)getconf.speclist FORCE
+ 	$(addprefix $(..)./scripts/mkinstalldirs ,\
+diff --git a/posix/execvpe.c b/posix/execvpe.c
+index d933f9c92a..7cdb06a611 100644
+--- a/posix/execvpe.c
++++ b/posix/execvpe.c
+@@ -48,12 +48,13 @@ maybe_script_execute (const char *file, char *const argv[], char *const envp[])
+ 	}
+     }
+ 
+-  /* Construct an argument list for the shell.  */
++  /* Construct an argument list for the shell.  It will contain at minimum 3
++     arguments (current shell, script, and an ending NULL.  */
+   char *new_argv[argc + 1];
+   new_argv[0] = (char *) _PATH_BSHELL;
+   new_argv[1] = (char *) file;
+   if (argc > 1)
+-    memcpy (new_argv + 2, argv + 1, argc * sizeof(char *));
++    memcpy (new_argv + 2, argv + 1, (argc - 1) * sizeof(char *));
+   else
+     new_argv[2] = NULL;
+ 
+@@ -91,10 +92,11 @@ __execvpe (const char *file, char *const argv[], char *const envp[])
+   /* Although GLIBC does not enforce NAME_MAX, we set it as the maximum
+      size to avoid unbounded stack allocation.  Same applies for
+      PATH_MAX.  */
+-  size_t file_len = __strnlen (file, NAME_MAX + 1);
++  size_t file_len = __strnlen (file, NAME_MAX) + 1;
+   size_t path_len = __strnlen (path, PATH_MAX - 1) + 1;
+ 
+-  if ((file_len > NAME_MAX)
++  /* NAME_MAX does not include the terminating null character.  */
++  if (((file_len-1) > NAME_MAX)
+       || !__libc_alloca_cutoff (path_len + file_len + 1))
+     {
+       errno = ENAMETOOLONG;
+@@ -103,6 +105,9 @@ __execvpe (const char *file, char *const argv[], char *const envp[])
+ 
+   const char *subp;
+   bool got_eacces = false;
++  /* The resulting string maximum size would be potentially a entry
++     in PATH plus '/' (path_len + 1) and then the the resulting file name
++     plus '\0' (file_len since it already accounts for the '\0').  */
+   char buffer[path_len + file_len + 1];
+   for (const char *p = path; ; p = subp)
+     {
+@@ -123,7 +128,7 @@ __execvpe (const char *file, char *const argv[], char *const envp[])
+          execute.  */
+       char *pend = mempcpy (buffer, p, subp - p);
+       *pend = '/';
+-      memcpy (pend + (p < subp), file, file_len + 1);
++      memcpy (pend + (p < subp), file, file_len);
+ 
+       __execve (buffer, argv, envp);
+ 
+diff --git a/posix/flexmember.h b/posix/flexmember.h
+new file mode 100644
+index 0000000000..107c1f09e9
+--- /dev/null
++++ b/posix/flexmember.h
+@@ -0,0 +1,45 @@
++/* Sizes of structs with flexible array members.
++
++   Copyright 2016-2017 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/>.
++
++   Written by Paul Eggert.  */
++
++#include <stddef.h>
++
++/* Nonzero multiple of alignment of TYPE, suitable for FLEXSIZEOF below.
++   On older platforms without _Alignof, use a pessimistic bound that is
++   safe in practice even if FLEXIBLE_ARRAY_MEMBER is 1.
++   On newer platforms, use _Alignof to get a tighter bound.  */
++
++#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112
++# define FLEXALIGNOF(type) (sizeof (type) & ~ (sizeof (type) - 1))
++#else
++# define FLEXALIGNOF(type) _Alignof (type)
++#endif
++
++/* Upper bound on the size of a struct of type TYPE with a flexible
++   array member named MEMBER that is followed by N bytes of other data.
++   This is not simply sizeof (TYPE) + N, since it may require
++   alignment on unusually picky C11 platforms, and
++   FLEXIBLE_ARRAY_MEMBER may be 1 on pre-C11 platforms.
++   Yield a value less than N if and only if arithmetic overflow occurs.  */
++
++#define FLEXSIZEOF(type, member, n) \
++   ((offsetof (type, member) + FLEXALIGNOF (type) - 1 + (n)) \
++    & ~ (FLEXALIGNOF (type) - 1))
+diff --git a/posix/glob.c b/posix/glob.c
+index ea4b0b61eb..f3fa807700 100644
+--- a/posix/glob.c
++++ b/posix/glob.c
+@@ -15,7 +15,7 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-#ifdef	HAVE_CONFIG_H
++#ifndef _LIBC
+ # include <config.h>
+ #endif
+ 
+@@ -27,29 +27,15 @@
+ #include <stdbool.h>
+ #include <stddef.h>
+ #include <stdint.h>
+-
+-/* Outcomment the following line for production quality code.  */
+-/* #define NDEBUG 1 */
+ #include <assert.h>
++#include <unistd.h>
+ 
+-#include <stdio.h>		/* Needed on stupid SunOS for assert.  */
+-
+-#if !defined _LIBC || !defined GLOB_ONLY_P
+-#if defined HAVE_UNISTD_H || defined _LIBC
+-# include <unistd.h>
+-# ifndef POSIX
+-#  ifdef _POSIX_VERSION
+-#   define POSIX
+-#  endif
+-# endif
++#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
++# define WINDOWS32
+ #endif
+ 
+-#include <pwd.h>
+-
+-#if defined HAVE_STDINT_H || defined _LIBC
+-# include <stdint.h>
+-#elif !defined UINTPTR_MAX
+-# define UINTPTR_MAX (~((size_t) 0))
++#ifndef WINDOWS32
++# include <pwd.h>
+ #endif
+ 
+ #include <errno.h>
+@@ -57,24 +43,7 @@
+ # define __set_errno(val) errno = (val)
+ #endif
+ 
+-#if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
+-# include <dirent.h>
+-#else
+-# define dirent direct
+-# ifdef HAVE_SYS_NDIR_H
+-#  include <sys/ndir.h>
+-# endif
+-# ifdef HAVE_SYS_DIR_H
+-#  include <sys/dir.h>
+-# endif
+-# ifdef HAVE_NDIR_H
+-#  include <ndir.h>
+-# endif
+-# ifdef HAVE_VMSDIR_H
+-#  include "vmsdir.h"
+-# endif /* HAVE_VMSDIR_H */
+-#endif
+-
++#include <dirent.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include <alloca.h>
+@@ -87,27 +56,29 @@
+ # define opendir(name) __opendir (name)
+ # define readdir(str) __readdir64 (str)
+ # define getpwnam_r(name, bufp, buf, len, res) \
+-   __getpwnam_r (name, bufp, buf, len, res)
++    __getpwnam_r (name, bufp, buf, len, res)
+ # ifndef __stat64
+ #  define __stat64(fname, buf) __xstat64 (_STAT_VER, fname, buf)
+ # endif
+ # define struct_stat64		struct stat64
++# define FLEXIBLE_ARRAY_MEMBER
+ #else /* !_LIBC */
+-# include "getlogin_r.h"
+-# include "mempcpy.h"
+-# include "stat-macros.h"
+-# include "strdup.h"
+-# define __stat64(fname, buf)	stat (fname, buf)
+-# define struct_stat64		struct stat
+-# define __stat(fname, buf)	stat (fname, buf)
+-# define __alloca		alloca
+-# define __readdir		readdir
+-# define __readdir64		readdir64
+-# define __glob_pattern_p	glob_pattern_p
++# define __getlogin_r(buf, len) getlogin_r (buf, len)
++# define __stat64(fname, buf)   stat (fname, buf)
++# define __fxstatat64(_, d, f, st, flag) fstatat (d, f, st, flag)
++# define struct_stat64          struct stat
++# ifndef __MVS__
++#  define __alloca              alloca
++# endif
++# define __readdir              readdir
++# define COMPILE_GLOB64
+ #endif /* _LIBC */
+ 
+ #include <fnmatch.h>
+ 
++#include <flexmember.h>
++#include <glob_internal.h>
++
+ #ifdef _SC_GETPW_R_SIZE_MAX
+ # define GETPW_R_SIZE_MAX()	sysconf (_SC_GETPW_R_SIZE_MAX)
+ #else
+@@ -121,61 +92,59 @@
+ 
+ static const char *next_brace_sub (const char *begin, int flags) __THROWNL;
+ 
++typedef uint_fast8_t dirent_type;
++
++#if !defined _LIBC && !defined HAVE_STRUCT_DIRENT_D_TYPE
++/* Any distinct values will do here.
++   Undef any existing macros out of the way.  */
++# undef DT_UNKNOWN
++# undef DT_DIR
++# undef DT_LNK
++# define DT_UNKNOWN 0
++# define DT_DIR 1
++# define DT_LNK 2
++#endif
++
+ /* A representation of a directory entry which does not depend on the
+    layout of struct dirent, or the size of ino_t.  */
+ struct readdir_result
+ {
+   const char *name;
+-# if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
+-  uint8_t type;
+-# endif
++#if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
++  dirent_type type;
++#endif
++#if defined _LIBC || defined D_INO_IN_DIRENT
+   bool skip_entry;
++#endif
+ };
+ 
+-# if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
+-/* Initializer based on the d_type member of struct dirent.  */
+-#  define D_TYPE_TO_RESULT(source) (source)->d_type,
+-
+-/* True if the directory entry D might be a symbolic link.  */
+-static bool
+-readdir_result_might_be_symlink (struct readdir_result d)
+-{
+-  return d.type == DT_UNKNOWN || d.type == DT_LNK;
+-}
+-
+-/* True if the directory entry D might be a directory.  */
+-static bool
+-readdir_result_might_be_dir (struct readdir_result d)
+-{
+-  return d.type == DT_DIR || readdir_result_might_be_symlink (d);
+-}
+-# else /* defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE */
+-#  define D_TYPE_TO_RESULT(source)
+-
+-/* If we do not have type information, symbolic links and directories
+-   are always a possibility.  */
+-
+-static bool
+-readdir_result_might_be_symlink (struct readdir_result d)
++/* Initialize and return type member of struct readdir_result.  */
++static dirent_type
++readdir_result_type (struct readdir_result d)
+ {
+-  return true;
++#if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
++# define D_TYPE_TO_RESULT(source) (source)->d_type,
++  return d.type;
++#else
++# define D_TYPE_TO_RESULT(source)
++  return DT_UNKNOWN;
++#endif
+ }
+ 
++/* Initialize and return skip_entry member of struct readdir_result.  */
+ static bool
+-readdir_result_might_be_dir (struct readdir_result d)
++readdir_result_skip_entry (struct readdir_result d)
+ {
+-  return true;
+-}
+-
+-# endif /* defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE */
+-
+-# if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
+ /* Initializer for skip_entry.  POSIX does not require that the d_ino
+    field be present, and some systems do not provide it. */
+-#  define D_INO_TO_RESULT(source) false,
+-# else
+-#  define D_INO_TO_RESULT(source) (source)->d_ino == 0,
+-# endif
++#if defined _LIBC || defined D_INO_IN_DIRENT
++# define D_INO_TO_RESULT(source) (source)->d_ino == 0,
++  return d.skip_entry;
++#else
++# define D_INO_TO_RESULT(source)
++  return false;
++#endif
++}
+ 
+ /* Construct an initializer for a struct readdir_result object from a
+    struct dirent *.  No copy of the name is made.  */
+@@ -186,8 +155,6 @@ readdir_result_might_be_dir (struct readdir_result d)
+     D_INO_TO_RESULT (source)		   \
+   }
+ 
+-#endif /* !defined _LIBC || !defined GLOB_ONLY_P */
+-
+ /* Call gl_readdir on STREAM.  This macro can be overridden to reduce
+    type safety if an old interface version needs to be supported.  */
+ #ifndef GL_READDIR
+@@ -225,18 +192,55 @@ convert_dirent64 (const struct dirent64 *source)
+ }
+ #endif
+ 
++#ifndef _LIBC
++/* The results of opendir() in this file are not used with dirfd and fchdir,
++   and we do not leak fds to any single-threaded code that could use stdio,
++   therefore save some unnecessary recursion in fchdir.c and opendir_safer.c.
++   FIXME - if the kernel ever adds support for multi-thread safety for
++   avoiding standard fds, then we should use opendir_safer.  */
++# ifdef GNULIB_defined_opendir
++#  undef opendir
++# endif
++# ifdef GNULIB_defined_closedir
++#  undef closedir
++# endif
+ 
+-#ifndef attribute_hidden
+-# define attribute_hidden
++/* Just use malloc.  */
++# define __libc_use_alloca(n) false
++# define alloca_account(len, avar) ((void) (len), (void) (avar), (void *) 0)
++# define extend_alloca_account(buf, len, newlen, avar) \
++    ((void) (buf), (void) (len), (void) (newlen), (void) (avar), (void *) 0)
+ #endif
+ 
++/* Set *R = A + B.  Return true if the answer is mathematically
++   incorrect due to overflow; in this case, *R is the low order
++   bits of the correct answer.  */
++
++static bool
++size_add_wrapv (size_t a, size_t b, size_t *r)
++{
++#if 5 <= __GNUC__ && !defined __ICC
++  return __builtin_add_overflow (a, b, r);
++#else
++  *r = a + b;
++  return *r < a;
++#endif
++}
++
++static bool
++glob_use_alloca (size_t alloca_used, size_t len)
++{
++  size_t size;
++  return (!size_add_wrapv (alloca_used, len, &size)
++          && __libc_use_alloca (size));
++}
++
+ static int glob_in_dir (const char *pattern, const char *directory,
+ 			int flags, int (*errfunc) (const char *, int),
+ 			glob_t *pglob, size_t alloca_used);
+ extern int __glob_pattern_type (const char *pattern, int quote)
+     attribute_hidden;
+ 
+-#if !defined _LIBC || !defined GLOB_ONLY_P
+ static int prefix_array (const char *prefix, char **array, size_t n) __THROWNL;
+ static int collated_compare (const void *, const void *) __THROWNL;
+ 
+@@ -265,16 +269,15 @@ next_brace_sub (const char *cp, int flags)
+   return *cp != '\0' ? cp : NULL;
+ }
+ 
+-#endif /* !defined _LIBC || !defined GLOB_ONLY_P */
+ 
+ /* Do glob searching for PATTERN, placing results in PGLOB.
+    The bits defined above may be set in FLAGS.
+    If a directory cannot be opened or read and ERRFUNC is not nil,
+    it is called with the pathname that caused the error, and the
+-   `errno' value from the failing call; if it returns non-zero
+-   `glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
++   'errno' value from the failing call; if it returns non-zero
++   'glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
+    If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
+-   Otherwise, `glob' returns zero.  */
++   Otherwise, 'glob' returns zero.  */
+ int
+ #ifdef GLOB_ATTRIBUTE
+ GLOB_ATTRIBUTE
+@@ -292,9 +295,7 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+   int malloc_dirname = 0;
+   glob_t dirs;
+   int retval = 0;
+-#ifdef _LIBC
+   size_t alloca_used = 0;
+-#endif
+ 
+   if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
+     {
+@@ -308,7 +309,7 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+     flags |= GLOB_ONLYDIR;
+ 
+   if (!(flags & GLOB_DOOFFS))
+-    /* Have to do this so `globfree' knows where to start freeing.  It
++    /* Have to do this so 'globfree' knows where to start freeing.  It
+        also makes all the code that uses gl_offs simpler. */
+     pglob->gl_offs = 0;
+ 
+@@ -350,14 +351,12 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	  size_t rest_len;
+ 	  char *onealt;
+ 	  size_t pattern_len = strlen (pattern) - 1;
+-#ifdef _LIBC
+-	  int alloca_onealt = __libc_use_alloca (alloca_used + pattern_len);
++	  int alloca_onealt = glob_use_alloca (alloca_used, pattern_len);
+ 	  if (alloca_onealt)
+ 	    onealt = alloca_account (pattern_len, alloca_used);
+ 	  else
+-#endif
+ 	    {
+-	      onealt = (char *) malloc (pattern_len);
++	      onealt = malloc (pattern_len);
+ 	      if (onealt == NULL)
+ 		{
+ 		  if (!(flags & GLOB_APPEND))
+@@ -377,11 +376,9 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	  next = next_brace_sub (begin + 1, flags);
+ 	  if (next == NULL)
+ 	    {
+-	      /* It is an illegal expression.  */
++	      /* It is an invalid expression.  */
+ 	    illegal_brace:
+-#ifdef _LIBC
+ 	      if (__glibc_unlikely (!alloca_onealt))
+-#endif
+ 		free (onealt);
+ 	      return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
+ 	    }
+@@ -429,9 +426,7 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	      /* If we got an error, return it.  */
+ 	      if (result && result != GLOB_NOMATCH)
+ 		{
+-#ifdef _LIBC
+ 		  if (__glibc_unlikely (!alloca_onealt))
+-#endif
+ 		    free (onealt);
+ 		  if (!(flags & GLOB_APPEND))
+ 		    {
+@@ -450,9 +445,7 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	      assert (next != NULL);
+ 	    }
+ 
+-#ifdef _LIBC
+ 	  if (__glibc_unlikely (!alloca_onealt))
+-#endif
+ 	    free (onealt);
+ 
+ 	  if (pglob->gl_pathc != firstc)
+@@ -489,14 +482,16 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 
+   /* Find the filename.  */
+   filename = strrchr (pattern, '/');
++
+ #if defined __MSDOS__ || defined WINDOWS32
+-  /* The case of "d:pattern".  Since `:' is not allowed in
++  /* The case of "d:pattern".  Since ':' is not allowed in
+      file names, we can safely assume that wherever it
+      happens in pattern, it signals the filename part.  This
+      is so we could some day support patterns like "[a-z]:foo".  */
+   if (filename == NULL)
+     filename = strchr (pattern, ':');
+ #endif /* __MSDOS__ || WINDOWS32 */
++
+   dirname_modified = 0;
+   if (filename == NULL)
+     {
+@@ -521,11 +516,7 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	    }
+ 
+ 	  filename = pattern;
+-#ifdef _AMIGA
+-	  dirname = (char *) "";
+-#else
+ 	  dirname = (char *) ".";
+-#endif
+ 	  dirlen = 0;
+ 	}
+     }
+@@ -549,22 +540,21 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	  char *drive_spec;
+ 
+ 	  ++dirlen;
+-	  drive_spec = (char *) __alloca (dirlen + 1);
++	  drive_spec = __alloca (dirlen + 1);
+ 	  *((char *) mempcpy (drive_spec, pattern, dirlen)) = '\0';
+ 	  /* For now, disallow wildcards in the drive spec, to
+ 	     prevent infinite recursion in glob.  */
+ 	  if (__glob_pattern_p (drive_spec, !(flags & GLOB_NOESCAPE)))
+ 	    return GLOB_NOMATCH;
+-	  /* If this is "d:pattern", we need to copy `:' to DIRNAME
++	  /* If this is "d:pattern", we need to copy ':' to DIRNAME
+ 	     as well.  If it's "d:/pattern", don't remove the slash
+ 	     from "d:/", since "d:" and "d:/" are not the same.*/
+ 	}
+ #endif
+-#ifdef _LIBC
+-      if (__libc_use_alloca (alloca_used + dirlen + 1))
++
++      if (glob_use_alloca (alloca_used, dirlen + 1))
+ 	newp = alloca_account (dirlen + 1, alloca_used);
+       else
+-#endif
+ 	{
+ 	  newp = malloc (dirlen + 1);
+ 	  if (newp == NULL)
+@@ -575,14 +565,17 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+       dirname = newp;
+       ++filename;
+ 
+-      if (filename[0] == '\0'
+ #if defined __MSDOS__ || defined WINDOWS32
+-	  && dirname[dirlen - 1] != ':'
+-	  && (dirlen < 3 || dirname[dirlen - 2] != ':'
+-	      || dirname[dirlen - 1] != '/')
++      bool drive_root = (dirlen > 1
++                         && (dirname[dirlen - 1] == ':'
++                             || (dirlen > 2 && dirname[dirlen - 2] == ':'
++                                 && dirname[dirlen - 1] == '/')));
++#else
++      bool drive_root = false;
+ #endif
+-	  && dirlen > 1)
+-	/* "pattern/".  Expand "pattern", appending slashes.  */
++
++      if (filename[0] == '\0' && dirlen > 1 && !drive_root)
++        /* "pattern/".  Expand "pattern", appending slashes.  */
+ 	{
+ 	  int orig_flags = flags;
+ 	  if (!(flags & GLOB_NOESCAPE) && dirname[dirlen - 1] == '\\')
+@@ -615,7 +608,6 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	}
+     }
+ 
+-#ifndef VMS
+   if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && dirname[0] == '~')
+     {
+       if (dirname[1] == '\0' || dirname[1] == '/'
+@@ -625,100 +617,127 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	  /* Look up home directory.  */
+ 	  char *home_dir = getenv ("HOME");
+ 	  int malloc_home_dir = 0;
+-# ifdef _AMIGA
+-	  if (home_dir == NULL || home_dir[0] == '\0')
+-	    home_dir = "SYS:";
+-# else
+-#  ifdef WINDOWS32
+-	  if (home_dir == NULL || home_dir[0] == '\0')
+-	    home_dir = "c:/users/default"; /* poor default */
+-#  else
+ 	  if (home_dir == NULL || home_dir[0] == '\0')
+ 	    {
++#ifdef WINDOWS32
++	      /* Windows NT defines HOMEDRIVE and HOMEPATH.  But give
++		 preference to HOME, because the user can change HOME.  */
++	      const char *home_drive = getenv ("HOMEDRIVE");
++	      const char *home_path = getenv ("HOMEPATH");
++
++	      if (home_drive != NULL && home_path != NULL)
++		{
++		  size_t home_drive_len = strlen (home_drive);
++		  size_t home_path_len = strlen (home_path);
++		  char *mem = alloca (home_drive_len + home_path_len + 1);
++
++		  memcpy (mem, home_drive, home_drive_len);
++		  memcpy (mem + home_drive_len, home_path, home_path_len + 1);
++		  home_dir = mem;
++		}
++	      else
++		home_dir = "c:/users/default"; /* poor default */
++#else
+ 	      int success;
+ 	      char *name;
++	      int malloc_name = 0;
+ 	      size_t buflen = GET_LOGIN_NAME_MAX () + 1;
+ 
+ 	      if (buflen == 0)
+-		/* `sysconf' does not support _SC_LOGIN_NAME_MAX.  Try
++		/* 'sysconf' does not support _SC_LOGIN_NAME_MAX.  Try
+ 		   a moderate value.  */
+ 		buflen = 20;
+-	      name = alloca_account (buflen, alloca_used);
++	      if (glob_use_alloca (alloca_used, buflen))
++		name = alloca_account (buflen, alloca_used);
++	      else
++		{
++		  name = malloc (buflen);
++		  if (name == NULL)
++		    {
++		      retval = GLOB_NOSPACE;
++		      goto out;
++		    }
++		  malloc_name = 1;
++		}
+ 
+ 	      success = __getlogin_r (name, buflen) == 0;
+ 	      if (success)
+ 		{
+ 		  struct passwd *p;
+-#   if defined HAVE_GETPWNAM_R || defined _LIBC
+-		  long int pwbuflen = GETPW_R_SIZE_MAX ();
++		  char *malloc_pwtmpbuf = NULL;
+ 		  char *pwtmpbuf;
++# if defined HAVE_GETPWNAM_R || defined _LIBC
++		  long int pwbuflenmax = GETPW_R_SIZE_MAX ();
++		  size_t pwbuflen = pwbuflenmax;
+ 		  struct passwd pwbuf;
+-		  int malloc_pwtmpbuf = 0;
+ 		  int save = errno;
+ 
+-#    ifndef _LIBC
+-		  if (pwbuflen == -1)
+-		    /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.
++#  ifndef _LIBC
++		  if (! (0 < pwbuflenmax && pwbuflenmax <= SIZE_MAX))
++		    /* 'sysconf' does not support _SC_GETPW_R_SIZE_MAX.
+ 		       Try a moderate value.  */
+ 		    pwbuflen = 1024;
+-#    endif
+-		  if (__libc_use_alloca (alloca_used + pwbuflen))
++#  endif
++		  if (glob_use_alloca (alloca_used, pwbuflen))
+ 		    pwtmpbuf = alloca_account (pwbuflen, alloca_used);
+ 		  else
+ 		    {
+ 		      pwtmpbuf = malloc (pwbuflen);
+ 		      if (pwtmpbuf == NULL)
+ 			{
++			  if (__glibc_unlikely (malloc_name))
++			    free (name);
+ 			  retval = GLOB_NOSPACE;
+ 			  goto out;
+ 			}
+-		      malloc_pwtmpbuf = 1;
++		      malloc_pwtmpbuf = pwtmpbuf;
+ 		    }
+ 
+ 		  while (getpwnam_r (name, &pwbuf, pwtmpbuf, pwbuflen, &p)
+ 			 != 0)
+ 		    {
++		      size_t newlen;
++		      bool v;
+ 		      if (errno != ERANGE)
+ 			{
+ 			  p = NULL;
+ 			  break;
+ 			}
+-
+-		      if (!malloc_pwtmpbuf
+-			  && __libc_use_alloca (alloca_used
+-						+ 2 * pwbuflen))
++		      v = size_add_wrapv (pwbuflen, pwbuflen, &newlen);
++		      if (!v && malloc_pwtmpbuf == NULL
++			  && glob_use_alloca (alloca_used, newlen))
+ 			pwtmpbuf = extend_alloca_account (pwtmpbuf, pwbuflen,
+-							  2 * pwbuflen,
+-							  alloca_used);
++							  newlen, alloca_used);
+ 		      else
+ 			{
+-			  char *newp = realloc (malloc_pwtmpbuf
+-						? pwtmpbuf : NULL,
+-						2 * pwbuflen);
++			  char *newp = (v ? NULL
++					: realloc (malloc_pwtmpbuf, newlen));
+ 			  if (newp == NULL)
+ 			    {
+-			      if (__glibc_unlikely (malloc_pwtmpbuf))
+-				free (pwtmpbuf);
++			      free (malloc_pwtmpbuf);
++			      if (__glibc_unlikely (malloc_name))
++				free (name);
+ 			      retval = GLOB_NOSPACE;
+ 			      goto out;
+ 			    }
+-			  pwtmpbuf = newp;
+-			  pwbuflen = 2 * pwbuflen;
+-			  malloc_pwtmpbuf = 1;
++			  malloc_pwtmpbuf = pwtmpbuf = newp;
+ 			}
++		      pwbuflen = newlen;
+ 		      __set_errno (save);
+ 		    }
+-#   else
++# else
+ 		  p = getpwnam (name);
+-#   endif
++# endif
++		  if (__glibc_unlikely (malloc_name))
++		    free (name);
+ 		  if (p != NULL)
+ 		    {
+-		      if (!malloc_pwtmpbuf)
++		      if (malloc_pwtmpbuf == NULL)
+ 			home_dir = p->pw_dir;
+ 		      else
+ 			{
+ 			  size_t home_dir_len = strlen (p->pw_dir) + 1;
+-			  if (__libc_use_alloca (alloca_used + home_dir_len))
++			  if (glob_use_alloca (alloca_used, home_dir_len))
+ 			    home_dir = alloca_account (home_dir_len,
+ 						       alloca_used);
+ 			  else
+@@ -733,26 +752,32 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 			      malloc_home_dir = 1;
+ 			    }
+ 			  memcpy (home_dir, p->pw_dir, home_dir_len);
+-
+-			  free (pwtmpbuf);
+ 			}
+ 		    }
++		  free (malloc_pwtmpbuf);
+ 		}
++	      else
++		{
++		  if (__glibc_unlikely (malloc_name))
++		    free (name);
++		}
++#endif /* WINDOWS32 */
+ 	    }
+ 	  if (home_dir == NULL || home_dir[0] == '\0')
+ 	    {
++	      if (__glibc_unlikely (malloc_home_dir))
++		free (home_dir);
+ 	      if (flags & GLOB_TILDE_CHECK)
+ 		{
+-		  if (__glibc_unlikely (malloc_home_dir))
+-		    free (home_dir);
+ 		  retval = GLOB_NOMATCH;
+ 		  goto out;
+ 		}
+ 	      else
+-		home_dir = (char *) "~"; /* No luck.  */
++		{
++		  home_dir = (char *) "~"; /* No luck.  */
++		  malloc_home_dir = 0;
++		}
+ 	    }
+-#  endif /* WINDOWS32 */
+-# endif
+ 	  /* Now construct the full directory.  */
+ 	  if (dirname[1] == '\0')
+ 	    {
+@@ -767,8 +792,7 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	    {
+ 	      char *newp;
+ 	      size_t home_len = strlen (home_dir);
+-	      int use_alloca = __libc_use_alloca (alloca_used
+-						  + home_len + dirlen);
++	      int use_alloca = glob_use_alloca (alloca_used, home_len + dirlen);
+ 	      if (use_alloca)
+ 		newp = alloca_account (home_len + dirlen, alloca_used);
+ 	      else
+@@ -792,12 +816,15 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	      dirname = newp;
+ 	      dirlen += home_len - 1;
+ 	      malloc_dirname = !use_alloca;
++
++	      if (__glibc_unlikely (malloc_home_dir))
++		free (home_dir);
+ 	    }
+ 	  dirname_modified = 1;
+ 	}
+-# if !defined _AMIGA && !defined WINDOWS32
+       else
+ 	{
++#ifndef WINDOWS32
+ 	  char *end_name = strchr (dirname, '/');
+ 	  char *user_name;
+ 	  int malloc_user_name = 0;
+@@ -819,7 +846,7 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	  else
+ 	    {
+ 	      char *newp;
+-	      if (__libc_use_alloca (alloca_used + (end_name - dirname)))
++	      if (glob_use_alloca (alloca_used, end_name - dirname))
+ 		newp = alloca_account (end_name - dirname, alloca_used);
+ 	      else
+ 		{
+@@ -836,11 +863,11 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 		  char *p = mempcpy (newp, dirname + 1,
+ 				     unescape - dirname - 1);
+ 		  char *q = unescape;
+-		  while (*q != '\0')
++		  while (q != end_name)
+ 		    {
+ 		      if (*q == '\\')
+ 			{
+-			  if (q[1] == '\0')
++			  if (q + 1 == end_name)
+ 			    {
+ 			      /* "~fo\\o\\" unescape to user_name "foo\\",
+ 				 but "~fo\\o\\/" unescape to user_name
+@@ -856,7 +883,7 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 		  *p = '\0';
+ 		}
+ 	      else
+-		*((char *) mempcpy (newp, dirname + 1, end_name - dirname))
++		*((char *) mempcpy (newp, dirname + 1, end_name - dirname - 1))
+ 		  = '\0';
+ 	      user_name = newp;
+ 	    }
+@@ -864,20 +891,21 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	  /* Look up specific user's home directory.  */
+ 	  {
+ 	    struct passwd *p;
++	    char *malloc_pwtmpbuf = NULL;
+ #  if defined HAVE_GETPWNAM_R || defined _LIBC
+-	    long int buflen = GETPW_R_SIZE_MAX ();
++	    long int buflenmax = GETPW_R_SIZE_MAX ();
++	    size_t buflen = buflenmax;
+ 	    char *pwtmpbuf;
+-	    int malloc_pwtmpbuf = 0;
+ 	    struct passwd pwbuf;
+ 	    int save = errno;
+ 
+ #   ifndef _LIBC
+-	    if (buflen == -1)
+-	      /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.  Try a
++	    if (! (0 <= buflenmax && buflenmax <= SIZE_MAX))
++	      /* Perhaps 'sysconf' does not support _SC_GETPW_R_SIZE_MAX.  Try a
+ 		 moderate value.  */
+ 	      buflen = 1024;
+ #   endif
+-	    if (__libc_use_alloca (alloca_used + buflen))
++	    if (glob_use_alloca (alloca_used, buflen))
+ 	      pwtmpbuf = alloca_account (buflen, alloca_used);
+ 	    else
+ 	      {
+@@ -890,32 +918,32 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 		    retval = GLOB_NOSPACE;
+ 		    goto out;
+ 		  }
+-		malloc_pwtmpbuf = 1;
++		malloc_pwtmpbuf = pwtmpbuf;
+ 	      }
+ 
+ 	    while (getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) != 0)
+ 	      {
++		size_t newlen;
++		bool v;
+ 		if (errno != ERANGE)
+ 		  {
+ 		    p = NULL;
+ 		    break;
+ 		  }
+-		if (!malloc_pwtmpbuf
+-		    && __libc_use_alloca (alloca_used + 2 * buflen))
++		v = size_add_wrapv (buflen, buflen, &newlen);
++		if (!v && malloc_pwtmpbuf == NULL
++		    && glob_use_alloca (alloca_used, newlen))
+ 		  pwtmpbuf = extend_alloca_account (pwtmpbuf, buflen,
+-						    2 * buflen, alloca_used);
++						    newlen, alloca_used);
+ 		else
+ 		  {
+-		    char *newp = realloc (malloc_pwtmpbuf ? pwtmpbuf : NULL,
+-					  2 * buflen);
++		    char *newp = v ? NULL : realloc (malloc_pwtmpbuf, newlen);
+ 		    if (newp == NULL)
+ 		      {
+-			if (__glibc_unlikely (malloc_pwtmpbuf))
+-			  free (pwtmpbuf);
++			free (malloc_pwtmpbuf);
+ 			goto nomem_getpw;
+ 		      }
+-		    pwtmpbuf = newp;
+-		    malloc_pwtmpbuf = 1;
++		    malloc_pwtmpbuf = pwtmpbuf = newp;
+ 		  }
+ 		__set_errno (save);
+ 	      }
+@@ -936,7 +964,7 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 		  free (dirname);
+ 		malloc_dirname = 0;
+ 
+-		if (__libc_use_alloca (alloca_used + home_len + rest_len + 1))
++		if (glob_use_alloca (alloca_used, home_len + rest_len + 1))
+ 		  dirname = alloca_account (home_len + rest_len + 1,
+ 					    alloca_used);
+ 		else
+@@ -944,8 +972,7 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 		    dirname = malloc (home_len + rest_len + 1);
+ 		    if (dirname == NULL)
+ 		      {
+-			if (__glibc_unlikely (malloc_pwtmpbuf))
+-			  free (pwtmpbuf);
++			free (malloc_pwtmpbuf);
+ 			retval = GLOB_NOSPACE;
+ 			goto out;
+ 		      }
+@@ -957,24 +984,24 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 		dirlen = home_len + rest_len;
+ 		dirname_modified = 1;
+ 
+-		if (__glibc_unlikely (malloc_pwtmpbuf))
+-		  free (pwtmpbuf);
++		free (malloc_pwtmpbuf);
+ 	      }
+ 	    else
+ 	      {
+-		if (__glibc_unlikely (malloc_pwtmpbuf))
+-		  free (pwtmpbuf);
++		free (malloc_pwtmpbuf);
+ 
+ 		if (flags & GLOB_TILDE_CHECK)
+-		  /* We have to regard it as an error if we cannot find the
+-		     home directory.  */
+-		  return GLOB_NOMATCH;
++		  {
++		    /* We have to regard it as an error if we cannot find the
++		       home directory.  */
++		    retval = GLOB_NOMATCH;
++		    goto out;
++		  }
+ 	      }
+ 	  }
++#endif /* !WINDOWS32 */
+ 	}
+-# endif	/* Not Amiga && not WINDOWS32.  */
+     }
+-#endif	/* Not VMS.  */
+ 
+   /* Now test whether we looked for "~" or "~NAME".  In this case we
+      can give the answer now.  */
+@@ -993,19 +1020,18 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	  size_t newcount = pglob->gl_pathc + pglob->gl_offs;
+ 	  char **new_gl_pathv;
+ 
+-	  if (newcount > UINTPTR_MAX - (1 + 1)
+-	      || newcount + 1 + 1 > ~((size_t) 0) / sizeof (char *))
++	  if (newcount > SIZE_MAX / sizeof (char *) - 2)
+ 	    {
+ 	    nospace:
+ 	      free (pglob->gl_pathv);
+ 	      pglob->gl_pathv = NULL;
+ 	      pglob->gl_pathc = 0;
+-	      return GLOB_NOSPACE;
++	      retval = GLOB_NOSPACE;
++	      goto out;
+ 	    }
+ 
+-	  new_gl_pathv
+-	    = (char **) realloc (pglob->gl_pathv,
+-				 (newcount + 1 + 1) * sizeof (char *));
++	  new_gl_pathv = realloc (pglob->gl_pathv,
++				  (newcount + 2) * sizeof (char *));
+ 	  if (new_gl_pathv == NULL)
+ 	    goto nospace;
+ 	  pglob->gl_pathv = new_gl_pathv;
+@@ -1019,12 +1045,19 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	      p = mempcpy (pglob->gl_pathv[newcount], dirname, dirlen);
+ 	      p[0] = '/';
+ 	      p[1] = '\0';
++	      if (__glibc_unlikely (malloc_dirname))
++		free (dirname);
+ 	    }
+ 	  else
+ 	    {
+-	      pglob->gl_pathv[newcount] = strdup (dirname);
+-	      if (pglob->gl_pathv[newcount] == NULL)
+-		goto nospace;
++	      if (__glibc_unlikely (malloc_dirname))
++		pglob->gl_pathv[newcount] = dirname;
++	      else
++		{
++		  pglob->gl_pathv[newcount] = strdup (dirname);
++		  if (pglob->gl_pathv[newcount] == NULL)
++		    goto nospace;
++		}
+ 	    }
+ 	  pglob->gl_pathv[++newcount] = NULL;
+ 	  ++pglob->gl_pathc;
+@@ -1034,7 +1067,8 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	}
+ 
+       /* Not found.  */
+-      return GLOB_NOMATCH;
++      retval = GLOB_NOMATCH;
++      goto out;
+     }
+ 
+   meta = __glob_pattern_type (dirname, !(flags & GLOB_NOESCAPE));
+@@ -1080,7 +1114,10 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+       if (status != 0)
+ 	{
+ 	  if ((flags & GLOB_NOCHECK) == 0 || status != GLOB_NOMATCH)
+-	    return status;
++	    {
++	      retval = status;
++	      goto out;
++	    }
+ 	  goto no_matches;
+ 	}
+ 
+@@ -1091,19 +1128,6 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	{
+ 	  size_t old_pathc;
+ 
+-#ifdef	SHELL
+-	  {
+-	    /* Make globbing interruptible in the bash shell. */
+-	    extern int interrupt_state;
+-
+-	    if (interrupt_state)
+-	      {
+-		globfree (&dirs);
+-		return GLOB_ABORTED;
+-	      }
+-	  }
+-#endif /* SHELL.  */
+-
+ 	  old_pathc = pglob->gl_pathc;
+ 	  status = glob_in_dir (filename, dirs.gl_pathv[i],
+ 				((flags | GLOB_APPEND)
+@@ -1118,7 +1142,8 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	      globfree (&dirs);
+ 	      globfree (pglob);
+ 	      pglob->gl_pathc = 0;
+-	      return status;
++	      retval = status;
++	      goto out;
+ 	    }
+ 
+ 	  /* Stick the directory on the front of each name.  */
+@@ -1129,13 +1154,14 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	      globfree (&dirs);
+ 	      globfree (pglob);
+ 	      pglob->gl_pathc = 0;
+-	      return GLOB_NOSPACE;
++	      retval = GLOB_NOSPACE;
++	      goto out;
+ 	    }
+ 	}
+ 
+       flags |= GLOB_MAGCHAR;
+ 
+-      /* We have ignored the GLOB_NOCHECK flag in the `glob_in_dir' calls.
++      /* We have ignored the GLOB_NOCHECK flag in the 'glob_in_dir' calls.
+ 	 But if we have not found any matching entry and the GLOB_NOCHECK
+ 	 flag was set we must return the input pattern itself.  */
+       if (pglob->gl_pathc + pglob->gl_offs == oldcount)
+@@ -1147,28 +1173,28 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	      size_t newcount = pglob->gl_pathc + pglob->gl_offs;
+ 	      char **new_gl_pathv;
+ 
+-	      if (newcount > UINTPTR_MAX - 2
+-		  || newcount + 2 > ~((size_t) 0) / sizeof (char *))
++	      if (newcount > SIZE_MAX / sizeof (char *) - 2)
+ 		{
+ 		nospace2:
+ 		  globfree (&dirs);
+-		  return GLOB_NOSPACE;
++		  retval = GLOB_NOSPACE;
++		  goto out;
+ 		}
+ 
+-	      new_gl_pathv = (char **) realloc (pglob->gl_pathv,
+-						(newcount + 2)
+-						* sizeof (char *));
++	      new_gl_pathv = realloc (pglob->gl_pathv,
++				      (newcount + 2) * sizeof (char *));
+ 	      if (new_gl_pathv == NULL)
+ 		goto nospace2;
+ 	      pglob->gl_pathv = new_gl_pathv;
+ 
+-	      pglob->gl_pathv[newcount] = __strdup (pattern);
++	      pglob->gl_pathv[newcount] = strdup (pattern);
+ 	      if (pglob->gl_pathv[newcount] == NULL)
+ 		{
+ 		  globfree (&dirs);
+ 		  globfree (pglob);
+ 		  pglob->gl_pathc = 0;
+-		  return GLOB_NOSPACE;
++		  retval = GLOB_NOSPACE;
++		  goto out;
+ 		}
+ 
+ 	      ++pglob->gl_pathc;
+@@ -1180,7 +1206,8 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	  else
+ 	    {
+ 	      globfree (&dirs);
+-	      return GLOB_NOMATCH;
++	      retval = GLOB_NOMATCH;
++	      goto out;
+ 	    }
+ 	}
+ 
+@@ -1226,7 +1253,8 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	      flags = orig_flags;
+ 	      goto no_matches;
+ 	    }
+-	  return status;
++	  retval = status;
++	  goto out;
+ 	}
+ 
+       if (dirlen > 0)
+@@ -1238,7 +1266,8 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	    {
+ 	      globfree (pglob);
+ 	      pglob->gl_pathc = 0;
+-	      return GLOB_NOSPACE;
++	      retval = GLOB_NOSPACE;
++	      goto out;
+ 	    }
+ 	}
+     }
+@@ -1263,7 +1292,8 @@ glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
+ 	      {
+ 		globfree (pglob);
+ 		pglob->gl_pathc = 0;
+-		return GLOB_NOSPACE;
++		retval = GLOB_NOSPACE;
++		goto out;
+ 	      }
+ 	    strcpy (&new[len - 2], "/");
+ 	    pglob->gl_pathv[i] = new;
+@@ -1289,32 +1319,12 @@ libc_hidden_def (glob)
+ #endif
+ 
+ 
+-#if !defined _LIBC || !defined GLOB_ONLY_P
+-
+-/* Free storage allocated in PGLOB by a previous `glob' call.  */
+-void
+-globfree (glob_t *pglob)
+-{
+-  if (pglob->gl_pathv != NULL)
+-    {
+-      size_t i;
+-      for (i = 0; i < pglob->gl_pathc; ++i)
+-	free (pglob->gl_pathv[pglob->gl_offs + i]);
+-      free (pglob->gl_pathv);
+-      pglob->gl_pathv = NULL;
+-    }
+-}
+-#if defined _LIBC && !defined globfree
+-libc_hidden_def (globfree)
+-#endif
+-
+-
+ /* Do a collated comparison of A and B.  */
+ static int
+ collated_compare (const void *a, const void *b)
+ {
+-  const char *const s1 = *(const char *const * const) a;
+-  const char *const s2 = *(const char *const * const) b;
++  char *const *ps1 = a; char *s1 = *ps1;
++  char *const *ps2 = b; char *s2 = *ps2;
+ 
+   if (s1 == s2)
+     return 0;
+@@ -1335,28 +1345,24 @@ prefix_array (const char *dirname, char **array, size_t n)
+ {
+   size_t i;
+   size_t dirlen = strlen (dirname);
+-#if defined __MSDOS__ || defined WINDOWS32
+-  int sep_char = '/';
+-# define DIRSEP_CHAR sep_char
+-#else
+-# define DIRSEP_CHAR '/'
+-#endif
++  char dirsep_char = '/';
+ 
+   if (dirlen == 1 && dirname[0] == '/')
+     /* DIRNAME is just "/", so normal prepending would get us "//foo".
+        We want "/foo" instead, so don't prepend any chars from DIRNAME.  */
+     dirlen = 0;
++
+ #if defined __MSDOS__ || defined WINDOWS32
+-  else if (dirlen > 1)
++  if (dirlen > 1)
+     {
+       if (dirname[dirlen - 1] == '/' && dirname[dirlen - 2] == ':')
+ 	/* DIRNAME is "d:/".  Don't prepend the slash from DIRNAME.  */
+ 	--dirlen;
+       else if (dirname[dirlen - 1] == ':')
+ 	{
+-	  /* DIRNAME is "d:".  Use `:' instead of `/'.  */
++	  /* DIRNAME is "d:".  Use ':' instead of '/'.  */
+ 	  --dirlen;
+-	  sep_char = ':';
++	  dirsep_char = ':';
+ 	}
+     }
+ #endif
+@@ -1364,7 +1370,7 @@ prefix_array (const char *dirname, char **array, size_t n)
+   for (i = 0; i < n; ++i)
+     {
+       size_t eltlen = strlen (array[i]) + 1;
+-      char *new = (char *) malloc (dirlen + 1 + eltlen);
++      char *new = malloc (dirlen + 1 + eltlen);
+       if (new == NULL)
+ 	{
+ 	  while (i > 0)
+@@ -1374,7 +1380,7 @@ prefix_array (const char *dirname, char **array, size_t n)
+ 
+       {
+ 	char *endp = mempcpy (new, dirname, dirlen);
+-	*endp++ = DIRSEP_CHAR;
++	*endp++ = dirsep_char;
+ 	mempcpy (endp, array[i], eltlen);
+       }
+       free (array[i]);
+@@ -1384,103 +1390,57 @@ prefix_array (const char *dirname, char **array, size_t n)
+   return 0;
+ }
+ 
+-
+-/* We must not compile this function twice.  */
+-#if !defined _LIBC || !defined NO_GLOB_PATTERN_P
+-int
+-__glob_pattern_type (const char *pattern, int quote)
+-{
+-  const char *p;
+-  int ret = 0;
+-
+-  for (p = pattern; *p != '\0'; ++p)
+-    switch (*p)
+-      {
+-      case '?':
+-      case '*':
+-	return 1;
+-
+-      case '\\':
+-	if (quote)
+-	  {
+-	    if (p[1] != '\0')
+-	      ++p;
+-	    ret |= 2;
+-	  }
+-	break;
+-
+-      case '[':
+-	ret |= 4;
+-	break;
+-
+-      case ']':
+-	if (ret & 4)
+-	  return 1;
+-	break;
+-      }
+-
+-  return ret;
+-}
+-
+-/* Return nonzero if PATTERN contains any metacharacters.
+-   Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
+-int
+-__glob_pattern_p (const char *pattern, int quote)
+-{
+-  return __glob_pattern_type (pattern, quote) == 1;
+-}
+-# ifdef _LIBC
+-weak_alias (__glob_pattern_p, glob_pattern_p)
+-# endif
+-#endif
+-
+-#endif /* !GLOB_ONLY_P */
+-
+-
+ /* We put this in a separate function mainly to allow the memory
+    allocated with alloca to be recycled.  */
+-#if !defined _LIBC || !defined GLOB_ONLY_P
+ static int
+ __attribute_noinline__
+-link_exists2_p (const char *dir, size_t dirlen, const char *fname,
+-	       glob_t *pglob
+-# ifndef _LIBC
+-		, int flags
++link_stat (const char *dir, size_t dirlen, const char *fname,
++	   glob_t *pglob
++# if !defined _LIBC && !HAVE_FSTATAT
++	   , int flags
+ # endif
+-		)
++	   )
+ {
+   size_t fnamelen = strlen (fname);
+-  char *fullname = (char *) __alloca (dirlen + 1 + fnamelen + 1);
++  char *fullname = __alloca (dirlen + 1 + fnamelen + 1);
+   struct stat st;
+-# ifndef _LIBC
+-  struct_stat64 st64;
+-# endif
+ 
+   mempcpy (mempcpy (mempcpy (fullname, dir, dirlen), "/", 1),
+ 	   fname, fnamelen + 1);
+ 
+-# ifdef _LIBC
+-  return (*pglob->gl_stat) (fullname, &st) == 0;
+-# else
+-  return ((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
+-	   ? (*pglob->gl_stat) (fullname, &st)
+-	   : __stat64 (fullname, &st64)) == 0);
++# if !defined _LIBC && !HAVE_FSTATAT
++  if (__builtin_expect ((flags & GLOB_ALTDIRFUNC) == 0, 1))
++    {
++      struct_stat64 st64;
++      return __stat64 (fullname, &st64);
++    }
+ # endif
++  return (*pglob->gl_stat) (fullname, &st);
+ }
+-# ifdef _LIBC
+-#  define link_exists_p(dfd, dirname, dirnamelen, fname, pglob, flags) \
+-  (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)			      \
+-   ? link_exists2_p (dirname, dirnamelen, fname, pglob)			      \
+-   : ({ struct stat64 st64;						      \
+-       __fxstatat64 (_STAT_VER, dfd, fname, &st64, 0) == 0; }))
++
++/* Return true if DIR/FNAME exists.  */
++static int
++link_exists_p (int dfd, const char *dir, size_t dirlen, const char *fname,
++	       glob_t *pglob, int flags)
++{
++  int status;
++# if defined _LIBC || HAVE_FSTATAT
++  if (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0))
++    status = link_stat (dir, dirlen, fname, pglob);
++  else
++    {
++      /* dfd cannot be -1 here, because dirfd never returns -1 on
++	 glibc, or on hosts that have fstatat.  */
++      struct_stat64 st64;
++      status = __fxstatat64 (_STAT_VER, dfd, fname, &st64, 0);
++    }
+ # else
+-#  define link_exists_p(dfd, dirname, dirnamelen, fname, pglob, flags) \
+-  link_exists2_p (dirname, dirnamelen, fname, pglob, flags)
++  status = link_stat (dir, dirlen, fname, pglob, flags);
+ # endif
+-#endif
+-
++  return status == 0 || errno == EOVERFLOW;
++}
+ 
+-/* Like `glob', but PATTERN is a final pathname component,
++/* Like 'glob', but PATTERN is a final pathname component,
+    and matches are searched for in DIRECTORY.
+    The GLOB_NOSORT bit in FLAGS is ignored.  No sorting is ever done.
+    The GLOB_APPEND flag is assumed to be set (always appends).  */
+@@ -1491,25 +1451,25 @@ glob_in_dir (const char *pattern, const char *directory, int flags,
+ {
+   size_t dirlen = strlen (directory);
+   void *stream = NULL;
+-  struct globnames
+-    {
+-      struct globnames *next;
+-      size_t count;
+-      char *name[64];
+-    };
+-#define INITIAL_COUNT sizeof (init_names.name) / sizeof (init_names.name[0])
+-  struct globnames init_names;
+-  struct globnames *names = &init_names;
+-  struct globnames *names_alloca = &init_names;
++# define GLOBNAMES_MEMBERS(nnames) \
++    struct globnames *next; size_t count; char *name[nnames];
++  struct globnames { GLOBNAMES_MEMBERS (FLEXIBLE_ARRAY_MEMBER) };
++  struct { GLOBNAMES_MEMBERS (64) } init_names_buf;
++  struct globnames *init_names = (struct globnames *) &init_names_buf;
++  struct globnames *names = init_names;
++  struct globnames *names_alloca = init_names;
+   size_t nfound = 0;
+   size_t cur = 0;
+   int meta;
+   int save;
++  int result;
+ 
+-  alloca_used += sizeof (init_names);
++  alloca_used += sizeof init_names_buf;
+ 
+-  init_names.next = NULL;
+-  init_names.count = INITIAL_COUNT;
++  init_names->next = NULL;
++  init_names->count = ((sizeof init_names_buf
++                        - offsetof (struct globnames, name))
++                       / sizeof init_names->name[0]);
+ 
+   meta = __glob_pattern_type (pattern, !(flags & GLOB_NOESCAPE));
+   if (meta == 0 && (flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))
+@@ -1529,14 +1489,16 @@ glob_in_dir (const char *pattern, const char *directory, int flags,
+ 	struct_stat64 st64;
+       } ust;
+       size_t patlen = strlen (pattern);
+-      int alloca_fullname = __libc_use_alloca (alloca_used
+-					       + dirlen + 1 + patlen + 1);
++      size_t fullsize;
++      bool alloca_fullname
++        = (! size_add_wrapv (dirlen + 1, patlen + 1, &fullsize)
++           && glob_use_alloca (alloca_used, fullsize));
+       char *fullname;
+       if (alloca_fullname)
+-	fullname = alloca_account (dirlen + 1 + patlen + 1, alloca_used);
++        fullname = alloca_account (fullsize, alloca_used);
+       else
+ 	{
+-	  fullname = malloc (dirlen + 1 + patlen + 1);
++	  fullname = malloc (fullsize);
+ 	  if (fullname == NULL)
+ 	    return GLOB_NOSPACE;
+ 	}
+@@ -1544,9 +1506,11 @@ glob_in_dir (const char *pattern, const char *directory, int flags,
+       mempcpy (mempcpy (mempcpy (fullname, directory, dirlen),
+ 			"/", 1),
+ 	       pattern, patlen + 1);
+-      if ((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
++      if (((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
+ 	   ? (*pglob->gl_stat) (fullname, &ust.st)
+-	   : __stat64 (fullname, &ust.st64)) == 0)
++	    : __stat64 (fullname, &ust.st64))
++	   == 0)
++	  || errno == EOVERFLOW)
+ 	/* We found this file to be existing.  Now tell the rest
+ 	   of the function to copy this name into the result.  */
+ 	flags |= GLOB_NOCHECK;
+@@ -1568,16 +1532,10 @@ glob_in_dir (const char *pattern, const char *directory, int flags,
+ 	}
+       else
+ 	{
+-#ifdef _LIBC
+ 	  int dfd = (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
+ 		     ? -1 : dirfd ((DIR *) stream));
+-#endif
+ 	  int fnm_flags = ((!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0)
+-			   | ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
+-#if defined _AMIGA || defined VMS
+-			   | FNM_CASEFOLD
+-#endif
+-			   );
++			   | ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0));
+ 	  flags |= GLOB_MAGCHAR;
+ 
+ 	  while (1)
+@@ -1597,19 +1555,24 @@ glob_in_dir (const char *pattern, const char *directory, int flags,
+ 	      }
+ 	      if (d.name == NULL)
+ 		break;
+-	      if (d.skip_entry)
++	      if (readdir_result_skip_entry (d))
+ 		continue;
+ 
+ 	      /* If we shall match only directories use the information
+ 		 provided by the dirent call if possible.  */
+-	      if ((flags & GLOB_ONLYDIR) && !readdir_result_might_be_dir (d))
+-		continue;
++	      if (flags & GLOB_ONLYDIR)
++		switch (readdir_result_type (d))
++		  {
++		  case DT_DIR: case DT_LNK: case DT_UNKNOWN: break;
++		  default: continue;
++		  }
+ 
+ 	      if (fnmatch (pattern, d.name, fnm_flags) == 0)
+ 		{
+ 		  /* If the file we found is a symlink we have to
+ 		     make sure the target file exists.  */
+-		  if (!readdir_result_might_be_symlink (d)
++		  dirent_type type = readdir_result_type (d);
++		  if (! (type == DT_LNK || type == DT_UNKNOWN)
+ 		      || link_exists_p (dfd, directory, dirlen, d.name,
+ 					pglob, flags))
+ 		    {
+@@ -1617,10 +1580,13 @@ glob_in_dir (const char *pattern, const char *directory, int flags,
+ 			{
+ 			  struct globnames *newnames;
+ 			  size_t count = names->count * 2;
+-			  size_t size = (sizeof (struct globnames)
+-					 + ((count - INITIAL_COUNT)
+-					    * sizeof (char *)));
+-			  if (__libc_use_alloca (alloca_used + size))
++			  size_t nameoff = offsetof (struct globnames, name);
++			  size_t size = FLEXSIZEOF (struct globnames, name,
++						    count * sizeof (char *));
++			  if ((SIZE_MAX - nameoff) / 2 / sizeof (char *)
++			      < names->count)
++			    goto memory_error;
++			  if (glob_use_alloca (alloca_used, size))
+ 			    newnames = names_alloca
+ 			      = alloca_account (size, alloca_used);
+ 			  else if ((newnames = malloc (size))
+@@ -1636,6 +1602,8 @@ glob_in_dir (const char *pattern, const char *directory, int flags,
+ 			goto memory_error;
+ 		      ++cur;
+ 		      ++nfound;
++		      if (SIZE_MAX - pglob->gl_offs <= nfound)
++			goto memory_error;
+ 		    }
+ 		}
+ 	    }
+@@ -1646,29 +1614,27 @@ glob_in_dir (const char *pattern, const char *directory, int flags,
+     {
+       size_t len = strlen (pattern);
+       nfound = 1;
+-      names->name[cur] = (char *) malloc (len + 1);
++      names->name[cur] = malloc (len + 1);
+       if (names->name[cur] == NULL)
+ 	goto memory_error;
+       *((char *) mempcpy (names->name[cur++], pattern, len)) = '\0';
+     }
+ 
+-  int result = GLOB_NOMATCH;
++  result = GLOB_NOMATCH;
+   if (nfound != 0)
+     {
++      char **new_gl_pathv;
+       result = 0;
+ 
+-      if (pglob->gl_pathc > UINTPTR_MAX - pglob->gl_offs
+-	  || pglob->gl_pathc + pglob->gl_offs > UINTPTR_MAX - nfound
+-	  || pglob->gl_pathc + pglob->gl_offs + nfound > UINTPTR_MAX - 1
+-	  || (pglob->gl_pathc + pglob->gl_offs + nfound + 1
+-	      > UINTPTR_MAX / sizeof (char *)))
++      if (SIZE_MAX / sizeof (char *) - pglob->gl_pathc
++	  < pglob->gl_offs + nfound + 1)
+ 	goto memory_error;
+ 
+-      char **new_gl_pathv;
+       new_gl_pathv
+-	= (char **) realloc (pglob->gl_pathv,
+-			     (pglob->gl_pathc + pglob->gl_offs + nfound + 1)
+-			     * sizeof (char *));
++	= realloc (pglob->gl_pathv,
++		   (pglob->gl_pathc + pglob->gl_offs + nfound + 1)
++		    * sizeof (char *));
++
+       if (new_gl_pathv == NULL)
+ 	{
+ 	memory_error:
+@@ -1684,7 +1650,7 @@ glob_in_dir (const char *pattern, const char *directory, int flags,
+ 		 and this is the block assigned to OLD here.  */
+ 	      if (names == NULL)
+ 		{
+-		  assert (old == &init_names);
++		  assert (old == init_names);
+ 		  break;
+ 		}
+ 	      cur = names->count;
+@@ -1710,7 +1676,7 @@ glob_in_dir (const char *pattern, const char *directory, int flags,
+ 		 and this is the block assigned to OLD here.  */
+ 	      if (names == NULL)
+ 		{
+-		  assert (old == &init_names);
++		  assert (old == init_names);
+ 		  break;
+ 		}
+ 	      cur = names->count;
+diff --git a/posix/glob64.c b/posix/glob64.c
+index a5f5a7f9e2..39e54afe8b 100644
+--- a/posix/glob64.c
++++ b/posix/glob64.c
+@@ -43,10 +43,4 @@ glob64 (const char *pattern, int flags,
+ }
+ libc_hidden_def (glob64)
+ 
+-void
+-globfree64 (glob64_t *pglob)
+-{
+-}
+-libc_hidden_def (globfree64)
+-
+ stub_warning (glob64)
+diff --git a/posix/glob_internal.h b/posix/glob_internal.h
+new file mode 100644
+index 0000000000..12c93660b7
+--- /dev/null
++++ b/posix/glob_internal.h
+@@ -0,0 +1,57 @@
++/* Shared definition for glob and glob_pattern_p.
++   Copyright (C) 2017 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/>.  */
++
++#ifndef GLOB_INTERNAL_H
++# define GLOB_INTERNAL_H
++
++static inline int
++__glob_pattern_type (const char *pattern, int quote)
++{
++  const char *p;
++  int ret = 0;
++
++  for (p = pattern; *p != '\0'; ++p)
++    switch (*p)
++      {
++      case '?':
++      case '*':
++        return 1;
++
++      case '\\':
++        if (quote)
++          {
++            if (p[1] != '\0')
++              ++p;
++            ret |= 2;
++          }
++        break;
++
++      case '[':
++        ret |= 4;
++        break;
++
++      case ']':
++        if (ret & 4)
++          return 1;
++        break;
++      }
++
++  return ret;
++}
++
++#endif /* GLOB_INTERNAL_H  */
+diff --git a/posix/glob_pattern_p.c b/posix/glob_pattern_p.c
+new file mode 100644
+index 0000000000..a17d337182
+--- /dev/null
++++ b/posix/glob_pattern_p.c
+@@ -0,0 +1,33 @@
++/* Return nonzero if PATTERN contains any metacharacters.
++   Copyright (C) 2017 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/>.  */
++
++#ifndef _LIBC
++# include <config.h>
++#endif
++
++#include <glob.h>
++#include "glob_internal.h"
++
++/* Return nonzero if PATTERN contains any metacharacters.
++   Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
++int
++__glob_pattern_p (const char *pattern, int quote)
++{
++  return __glob_pattern_type (pattern, quote) == 1;
++}
++weak_alias (__glob_pattern_p, glob_pattern_p)
+diff --git a/posix/globfree.c b/posix/globfree.c
+new file mode 100644
+index 0000000000..042e29d9b0
+--- /dev/null
++++ b/posix/globfree.c
+@@ -0,0 +1,41 @@
++/* Frees the dynamically allocated storage from an earlier call to glob.
++   Copyright (C) 2017 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/>.  */
++
++#ifndef _LIBC
++# include <config.h>
++#endif
++
++#include <glob.h>
++#include <stdlib.h>
++
++/* Free storage allocated in PGLOB by a previous `glob' call.  */
++void
++globfree (glob_t *pglob)
++{
++  if (pglob->gl_pathv != NULL)
++    {
++      size_t i;
++      for (i = 0; i < pglob->gl_pathc; ++i)
++        free (pglob->gl_pathv[pglob->gl_offs + i]);
++      free (pglob->gl_pathv);
++      pglob->gl_pathv = NULL;
++    }
++}
++#ifndef globfree
++libc_hidden_def (globfree)
++#endif
+diff --git a/sysdeps/unix/sysv/linux/sh/pread.c b/posix/globfree64.c
+similarity index 68%
+rename from sysdeps/unix/sysv/linux/sh/pread.c
+rename to posix/globfree64.c
+index d3f99f35db..c9f8908a4e 100644
+--- a/sysdeps/unix/sysv/linux/sh/pread.c
++++ b/posix/globfree64.c
+@@ -1,6 +1,6 @@
+-/* Copyright (C) 1997-2016 Free Software Foundation, Inc.
++/* Frees the dynamically allocated storage from an earlier call to glob.
++   Copyright (C) 2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -16,8 +16,16 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-/* SH4 ABI does not really require argument alignment for 64-bits, but
+-   the kernel interface for pread adds a dummy long argument before the
+-   offset.  */
+-#define __ALIGNMENT_ARG
+-#include <sysdeps/unix/sysv/linux/pread.c>
++#ifndef _LIBC
++# include <config.h>
++#endif
++
++#include <glob.h>
++#include <stdlib.h>
++
++/* Free storage allocated in PGLOB by a previous `glob' call.  */
++void
++globfree64 (glob64_t *pglob)
++{
++}
++libc_hidden_def (globfree64)
+diff --git a/posix/tst-glob-tilde.c b/posix/tst-glob-tilde.c
+new file mode 100644
+index 0000000000..6886f4371f
+--- /dev/null
++++ b/posix/tst-glob-tilde.c
+@@ -0,0 +1,143 @@
++/* Check for GLOB_TIDLE heap allocation issues (bugs 22320, 22325, 22332).
++   Copyright (C) 2017 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 <glob.h>
++#include <mcheck.h>
++#include <nss.h>
++#include <pwd.h>
++#include <stdlib.h>
++#include <string.h>
++#include <support/check.h>
++#include <support/support.h>
++
++/* Flag which indicates whether to pass the GLOB_ONLYDIR flag.  */
++static int do_onlydir;
++
++/* Flag which indicates whether to pass the GLOB_NOCHECK flag.  */
++static int do_nocheck;
++
++/* Flag which indicates whether to pass the GLOB_MARK flag.  */
++static int do_mark;
++
++/* Flag which indicates whether to pass the GLOB_NOESCAPE flag.  */
++static int do_noescape;
++
++static void
++one_test (const char *prefix, const char *middle, const char *suffix)
++{
++  char *pattern = xasprintf ("%s%s%s", prefix, middle, suffix);
++  int flags = GLOB_TILDE;
++  if (do_onlydir)
++    flags |= GLOB_ONLYDIR;
++  if (do_nocheck)
++    flags |= GLOB_NOCHECK;
++  if (do_mark)
++    flags |= GLOB_MARK;
++  if (do_noescape)
++    flags |= GLOB_NOESCAPE;
++  glob_t gl;
++  /* This glob call might result in crashes or memory leaks.  */
++  if (glob (pattern, flags, NULL, &gl) == 0)
++    globfree (&gl);
++  free (pattern);
++}
++
++enum
++  {
++    /* The largest base being tested.  */
++    largest_base_size = 500000,
++
++    /* The actual size is the base size plus a variable whose absolute
++       value is not greater than this.  This helps malloc to trigger
++       overflows.  */
++    max_size_skew = 16,
++
++    /* The maximum string length supported by repeating_string
++       below.  */
++    repeat_size = largest_base_size + max_size_skew,
++  };
++
++/* Used to construct strings which repeat a single character 'x'.  */
++static char *repeat;
++
++/* Return a string of SIZE characters.  */
++const char *
++repeating_string (int size)
++{
++  TEST_VERIFY (size >= 0);
++  TEST_VERIFY (size <= repeat_size);
++  const char *repeated_shifted = repeat + repeat_size - size;
++  TEST_VERIFY (strlen (repeated_shifted) == size);
++  return repeated_shifted;
++}
++
++static int
++do_test (void)
++{
++  /* Avoid network-based NSS modules and initialize nss_files with a
++     dummy lookup.  This has to come before mtrace because NSS does
++     not free all memory.  */
++  __nss_configure_lookup ("passwd", "files");
++  (void) getpwnam ("root");
++
++  mtrace ();
++
++  repeat = xmalloc (repeat_size + 1);
++  memset (repeat, 'x', repeat_size);
++  repeat[repeat_size] = '\0';
++
++  /* These numbers control the size of the user name.  The values
++     cover the minimum (0), a typical size (8), a large
++     stack-allocated size (100000), and a somewhat large
++     heap-allocated size (largest_base_size).  */
++  static const int base_sizes[] = { 0, 8, 100, 100000, largest_base_size, -1 };
++
++  for (do_onlydir = 0; do_onlydir < 2; ++do_onlydir)
++    for (do_nocheck = 0; do_nocheck < 2; ++do_nocheck)
++      for (do_mark = 0; do_mark < 2; ++do_mark)
++	for (do_noescape = 0; do_noescape < 2; ++do_noescape)
++	  for (int base_idx = 0; base_sizes[base_idx] >= 0; ++base_idx)
++	    {
++	      for (int size_skew = -max_size_skew; size_skew <= max_size_skew;
++		   ++size_skew)
++		{
++		  int size = base_sizes[base_idx] + size_skew;
++		  if (size < 0)
++		    continue;
++
++		  const char *user_name = repeating_string (size);
++		  one_test ("~", user_name, "/a/b");
++		  one_test ("~", user_name, "x\\x\\x////x\\a");
++		}
++
++	      const char *user_name = repeating_string (base_sizes[base_idx]);
++	      one_test ("~", user_name, "");
++	      one_test ("~", user_name, "/");
++	      one_test ("~", user_name, "/a");
++	      one_test ("~", user_name, "/*/*");
++	      one_test ("~", user_name, "\\/");
++	      one_test ("/~", user_name, "");
++	      one_test ("*/~", user_name, "/a/b");
++	    }
++
++  free (repeat);
++
++  return 0;
++}
++
++#include <support/test-driver.c>
+diff --git a/resolv/Makefile b/resolv/Makefile
+index 8be41d3ae1..a4c86b9762 100644
+--- a/resolv/Makefile
++++ b/resolv/Makefile
+@@ -40,6 +40,9 @@ ifeq ($(have-thread-library),yes)
+ extra-libs += libanl
+ routines += gai_sigqueue
+ tests += tst-res_hconf_reorder
++
++# This test sends millions of packets and is rather slow.
++xtests += tst-resolv-qtypes
+ endif
+ extra-libs-others = $(extra-libs)
+ libresolv-routines := gethnamaddr res_comp res_debug	\
+@@ -117,3 +120,5 @@ tst-leaks2-ENV = MALLOC_TRACE=$(objpfx)tst-leaks2.mtrace
+ $(objpfx)mtrace-tst-leaks2.out: $(objpfx)tst-leaks2.out
+ 	$(common-objpfx)malloc/mtrace $(objpfx)tst-leaks2.mtrace > $@; \
+ 	$(evaluate-test)
++
++$(objpfx)tst-resolv-qtypes: $(objpfx)libresolv.so $(shared-thread-library)
+diff --git a/resolv/nss_dns/dns-host.c b/resolv/nss_dns/dns-host.c
+index 5f9e35701b..d16fa4b8ed 100644
+--- a/resolv/nss_dns/dns-host.c
++++ b/resolv/nss_dns/dns-host.c
+@@ -323,7 +323,7 @@ _nss_dns_gethostbyname4_r (const char *name, struct gaih_addrtuple **pat,
+ 
+   int olderr = errno;
+   enum nss_status status;
+-  int n = __libc_res_nsearch (&_res, name, C_IN, T_UNSPEC,
++  int n = __libc_res_nsearch (&_res, name, C_IN, T_QUERY_A_AND_AAAA,
+ 			      host_buffer.buf->buf, 2048, &host_buffer.ptr,
+ 			      &ans2p, &nans2p, &resplen2, &ans2p_malloced);
+   if (n >= 0)
+diff --git a/resolv/res_mkquery.c b/resolv/res_mkquery.c
+index 12f9730199..d80b5318e5 100644
+--- a/resolv/res_mkquery.c
++++ b/resolv/res_mkquery.c
+@@ -103,6 +103,10 @@ res_nmkquery(res_state statp,
+ 	int n;
+ 	u_char *dnptrs[20], **dpp, **lastdnptr;
+ 
++	if (class < 0 || class > 65535
++	    || type < 0 || type > 65535)
++	  return -1;
++
+ #ifdef DEBUG
+ 	if (statp->options & RES_DEBUG)
+ 		printf(";; res_nmkquery(%s, %s, %s, %s)\n",
+diff --git a/resolv/res_query.c b/resolv/res_query.c
+index 944d1a90f5..07dc6f6583 100644
+--- a/resolv/res_query.c
++++ b/resolv/res_query.c
+@@ -122,7 +122,7 @@ __libc_res_nquery(res_state statp,
+ 	int n, use_malloc = 0;
+ 	u_int oflags = statp->_flags;
+ 
+-	size_t bufsize = (type == T_UNSPEC ? 2 : 1) * QUERYSIZE;
++	size_t bufsize = (type == T_QUERY_A_AND_AAAA ? 2 : 1) * QUERYSIZE;
+ 	u_char *buf = alloca (bufsize);
+ 	u_char *query1 = buf;
+ 	int nquery1 = -1;
+@@ -137,7 +137,7 @@ __libc_res_nquery(res_state statp,
+ 		printf(";; res_query(%s, %d, %d)\n", name, class, type);
+ #endif
+ 
+-	if (type == T_UNSPEC)
++	if (type == T_QUERY_A_AND_AAAA)
+ 	  {
+ 	    n = res_nmkquery(statp, QUERY, name, class, T_A, NULL, 0, NULL,
+ 			     query1, bufsize);
+@@ -190,7 +190,7 @@ __libc_res_nquery(res_state statp,
+ 	if (__builtin_expect (n <= 0, 0) && !use_malloc) {
+ 		/* Retry just in case res_nmkquery failed because of too
+ 		   short buffer.  Shouldn't happen.  */
+-		bufsize = (type == T_UNSPEC ? 2 : 1) * MAXPACKET;
++		bufsize = (type == T_QUERY_A_AND_AAAA ? 2 : 1) * MAXPACKET;
+ 		buf = malloc (bufsize);
+ 		if (buf != NULL) {
+ 			query1 = buf;
+diff --git a/resolv/tst-resolv-qtypes.c b/resolv/tst-resolv-qtypes.c
+new file mode 100644
+index 0000000000..b3e60c693b
+--- /dev/null
++++ b/resolv/tst-resolv-qtypes.c
+@@ -0,0 +1,185 @@
++/* Exercise low-level query functions with different QTYPEs.
++   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 <resolv.h>
++#include <string.h>
++#include <support/check.h>
++#include <support/check_nss.h>
++#include <support/resolv_test.h>
++#include <support/support.h>
++#include <support/test-driver.h>
++#include <support/xmemstream.h>
++
++/* If ture, the response function will send the actual response packet
++   over TCP instead of UDP.  */
++static volatile bool force_tcp;
++
++/* Send back a fake resource record matching the QTYPE.  */
++static void
++response (const struct resolv_response_context *ctx,
++          struct resolv_response_builder *b,
++          const char *qname, uint16_t qclass, uint16_t qtype)
++{
++  if (force_tcp && ctx->tcp)
++    {
++      resolv_response_init (b, (struct resolv_response_flags) { .tc = 1 });
++      resolv_response_add_question (b, qname, qclass, qtype);
++      return;
++    }
++
++  resolv_response_init (b, (struct resolv_response_flags) { });
++  resolv_response_add_question (b, qname, qclass, qtype);
++  resolv_response_section (b, ns_s_an);
++  resolv_response_open_record (b, qname, qclass, qtype, 0);
++  resolv_response_add_data (b, &qtype, sizeof (qtype));
++  resolv_response_close_record (b);
++}
++
++static const const char *domain = "www.example.com";
++
++static int
++wrap_res_query (int type, unsigned char *answer, int answer_length)
++{
++  return res_query (domain, C_IN, type, answer, answer_length);
++}
++
++static int
++wrap_res_search (int type, unsigned char *answer, int answer_length)
++{
++  return res_query (domain, C_IN, type, answer, answer_length);
++}
++
++static int
++wrap_res_querydomain (int type, unsigned char *answer, int answer_length)
++{
++  return res_querydomain ("www", "example.com", C_IN, type,
++                           answer, answer_length);
++}
++
++static int
++wrap_res_send (int type, unsigned char *answer, int answer_length)
++{
++  unsigned char buf[512];
++  int ret = res_mkquery (QUERY, domain, C_IN, type,
++                         (const unsigned char *) "", 0, NULL,
++                         buf, sizeof (buf));
++  if (type < 0 || type >= 65536)
++    {
++      /* res_mkquery fails for out-of-range record types.  */
++      TEST_VERIFY_EXIT (ret == -1);
++      return -1;
++    }
++  TEST_VERIFY_EXIT (ret > 12);  /* DNS header length.  */
++  return res_send (buf, ret, answer, answer_length);
++}
++
++static int
++wrap_res_nquery (int type, unsigned char *answer, int answer_length)
++{
++  return res_nquery (&_res, domain, C_IN, type, answer, answer_length);
++}
++
++static int
++wrap_res_nsearch (int type, unsigned char *answer, int answer_length)
++{
++  return res_nquery (&_res, domain, C_IN, type, answer, answer_length);
++}
++
++static int
++wrap_res_nquerydomain (int type, unsigned char *answer, int answer_length)
++{
++  return res_nquerydomain (&_res, "www", "example.com", C_IN, type,
++                           answer, answer_length);
++}
++
++static int
++wrap_res_nsend (int type, unsigned char *answer, int answer_length)
++{
++  unsigned char buf[512];
++  int ret = res_nmkquery (&_res, QUERY, domain, C_IN, type,
++                         (const unsigned char *) "", 0, NULL,
++                         buf, sizeof (buf));
++  if (type < 0 || type >= 65536)
++    {
++      /* res_mkquery fails for out-of-range record types.  */
++      TEST_VERIFY_EXIT (ret == -1);
++      return -1;
++    }
++  TEST_VERIFY_EXIT (ret > 12);  /* DNS header length.  */
++  return res_nsend (&_res, buf, ret, answer, answer_length);
++}
++
++static void
++test_function (const char *fname,
++               int (*func) (int type,
++                            unsigned char *answer, int answer_length))
++{
++  unsigned char buf[512];
++  for (int tcp = 0; tcp < 2; ++tcp)
++    {
++      force_tcp = tcp;
++      for (unsigned int type = 1; type <= 65535; ++type)
++        {
++          if (test_verbose)
++            printf ("info: sending QTYPE %d with %s (tcp=%d)\n",
++                    type, fname, tcp);
++          int ret = func (type, buf, sizeof (buf));
++          if (ret != 47)
++            FAIL_EXIT1 ("%s tcp=%d qtype=%d return value %d",
++                        fname,tcp, type, ret);
++          /* One question, one answer record.  */
++          TEST_VERIFY (memcmp (buf + 4, "\0\1\0\1\0\0\0\0", 8) == 0);
++          /* Question section.  */
++          static const char qname[] = "\3www\7example\3com";
++          size_t qname_length = sizeof (qname);
++          TEST_VERIFY (memcmp (buf + 12, qname, qname_length) == 0);
++          /* RDATA part of answer.  */
++          uint16_t type16 = type;
++          TEST_VERIFY (memcmp (buf + ret - 2, &type16, sizeof (type16)) == 0);
++        }
++    }
++
++  TEST_VERIFY (func (-1, buf, sizeof (buf) == -1));
++  TEST_VERIFY (func (65536, buf, sizeof (buf) == -1));
++}
++
++static int
++do_test (void)
++{
++  struct resolv_redirect_config config =
++    {
++      .response_callback = response,
++    };
++  struct resolv_test *obj = resolv_test_start (config);
++
++  test_function ("res_query", &wrap_res_query);
++  test_function ("res_search", &wrap_res_search);
++  test_function ("res_querydomain", &wrap_res_querydomain);
++  test_function ("res_send", &wrap_res_send);
++
++  test_function ("res_nquery", &wrap_res_nquery);
++  test_function ("res_nsearch", &wrap_res_nsearch);
++  test_function ("res_nquerydomain", &wrap_res_nquerydomain);
++  test_function ("res_nsend", &wrap_res_nsend);
++
++  resolv_test_end (obj);
++  return 0;
++}
++
++#define TIMEOUT 300
++#include <support/test-driver.c>
+diff --git a/scripts/backport-support.sh b/scripts/backport-support.sh
+new file mode 100644
+index 0000000000..2ece7ce575
+--- /dev/null
++++ b/scripts/backport-support.sh
+@@ -0,0 +1,110 @@
++#!/bin/bash
++# Create a patch which backports the support/ subdirectory.
++# Copyright (C) 2017 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 does not backport the Makefile tweaks outside the
++# support/ directory (which need to be backported separately), or the
++# changes to test-skeleton.c (which should not be backported).
++
++set -e
++
++export LC_ALL=C
++export GIT_CONFIG=/dev/null
++export GTT_CONFIG_NOSYSTEM=0
++export GIT_PAGER=
++
++usage () {
++    cat >&2 <<EOF
++usage: $0 {patch|commit}
++EOF
++    exit 1
++}
++
++if test $# -ne 1 ; then
++    usage
++fi
++
++command="$1"
++
++case "$command" in
++    patch|commit)
++    ;;
++    *)
++	usage
++	;;
++esac
++
++# The upstream branch to work on.
++branch=origin/master
++
++# The commit which added the support/ directory.
++initial_commit=c23de0aacbeaa7a091609b35764bed931475a16d
++
++# We backport the support directory and this script.  Directories need
++# to end in a /.
++patch_targets="support/ scripts/backport-support.sh"
++
++latest_commit="$(git log --max-count=1 --pretty=format:%H "$branch" -- \
++  $patch_targets)"
++
++# Simplify the branch name somewhat for reporting.
++branch_name="$(echo "$branch" | sed s,^origin/,,)"
++
++command_patch () {
++    cat <<EOF
++This patch creates the contents of the support/ directory up to this
++upstream commit on the $branch_name branch:
++
++EOF
++    git log --max-count=1 "$latest_commit"
++    echo
++    git diff "$initial_commit"^.."$latest_commit" $patch_targets
++    echo "# Before applying the patch, run this command:" >&2
++    echo "# rm -rf $patch_targets" >&2
++}
++
++command_commit () {
++    git status --porcelain | while read line ; do
++	echo "error: working copy is not clean, cannot commit" >&2
++	exit 1
++    done
++    for path in $patch_targets; do
++	echo "# Processing $path" >&2
++	case "$path" in
++	    [a-zA-Z0-9]*/)
++		# Directory.
++		git rm --cached --ignore-unmatch -r "$path"
++		rm -rf "$path"
++		git read-tree --prefix="$path" "$latest_commit":"$path"
++		git checkout "$path"
++		;;
++	    *)
++		# File.
++		git show "$latest_commit":"$path" > "$path"
++		git add "$path"
++	esac
++    done
++    git commit -m "Synchronize support/ infrastructure with $branch_name
++
++This commit updates the support/ subdirectory to
++commit $latest_commit
++on the $branch_name branch.
++"
++}
++
++command_$command
+diff --git a/sunrpc/Makefile b/sunrpc/Makefile
+index 789ef423e5..1e91905011 100644
+--- a/sunrpc/Makefile
++++ b/sunrpc/Makefile
+@@ -96,13 +96,18 @@ rpcgen-objs = rpc_main.o rpc_hout.o rpc_cout.o rpc_parse.o \
+ extra-objs = $(rpcgen-objs) $(addprefix cross-,$(rpcgen-objs))
+ others += rpcgen
+ 
+-tests = tst-xdrmem tst-xdrmem2 test-rpcent
++tests = tst-xdrmem tst-xdrmem2 test-rpcent tst-udp-error
+ xtests := tst-getmyaddr
+ 
+ ifeq ($(have-thread-library),yes)
+ xtests += thrsvc
+ endif
+ 
++ifeq ($(run-built-tests),yes)
++rpcgen-tests := $(objpfx)bug20790.out
++tests-special += $(rpcgen-tests)
++endif
++
+ headers += $(rpcsvc:%.x=rpcsvc/%.h)
+ extra-libs := librpcsvc
+ extra-libs-others := librpcsvc # Make it in `others' pass, not `lib' pass.
+@@ -153,6 +158,7 @@ BUILD_CPPFLAGS += $(sunrpc-CPPFLAGS)
+ $(objpfx)tst-getmyaddr: $(common-objpfx)linkobj/libc.so
+ $(objpfx)tst-xdrmem: $(common-objpfx)linkobj/libc.so
+ $(objpfx)tst-xdrmem2: $(common-objpfx)linkobj/libc.so
++$(objpfx)tst-udp-error: $(common-objpfx)linkobj/libc.so
+ 
+ $(objpfx)rpcgen: $(addprefix $(objpfx),$(rpcgen-objs))
+ 
+@@ -225,3 +231,9 @@ endif
+ endif
+ 
+ $(objpfx)thrsvc: $(common-objpfx)linkobj/libc.so $(shared-thread-library)
++
++ifeq ($(run-built-tests),yes)
++$(rpcgen-tests): $(objpfx)%.out: %.x $(objpfx)rpcgen
++	$(built-program-cmd) -c $< -o $@; \
++	$(evaluate-test)
++endif
+diff --git a/sunrpc/bug20790.x b/sunrpc/bug20790.x
+new file mode 100644
+index 0000000000..a00c9b3830
+--- /dev/null
++++ b/sunrpc/bug20790.x
+@@ -0,0 +1 @@
++program TPROG { version TVERS { int FUNC(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) = 1; } = 1; } = 1;
+diff --git a/sunrpc/clnt_udp.c b/sunrpc/clnt_udp.c
+index 4d9acb1e6a..1de25cb771 100644
+--- a/sunrpc/clnt_udp.c
++++ b/sunrpc/clnt_udp.c
+@@ -421,9 +421,9 @@ send_again:
+ 		 cmsg = CMSG_NXTHDR (&msg, cmsg))
+ 	      if (cmsg->cmsg_level == SOL_IP && cmsg->cmsg_type == IP_RECVERR)
+ 		{
+-		  free (cbuf);
+ 		  e = (struct sock_extended_err *) CMSG_DATA(cmsg);
+ 		  cu->cu_error.re_errno = e->ee_errno;
++		  free (cbuf);
+ 		  return (cu->cu_error.re_status = RPC_CANTRECV);
+ 		}
+ 	  free (cbuf);
+diff --git a/sunrpc/rpc_parse.c b/sunrpc/rpc_parse.c
+index 1a1df6d8c2..505a6554cf 100644
+--- a/sunrpc/rpc_parse.c
++++ b/sunrpc/rpc_parse.c
+@@ -521,7 +521,7 @@ static void
+ get_prog_declaration (declaration * dec, defkind dkind, int num /* arg number */ )
+ {
+   token tok;
+-  char name[10];		/* argument name */
++  char name[MAXLINESIZE];		/* argument name */
+ 
+   if (dkind == DEF_PROGRAM)
+     {
+diff --git a/sunrpc/tst-udp-error.c b/sunrpc/tst-udp-error.c
+new file mode 100644
+index 0000000000..1efc02f5c6
+--- /dev/null
++++ b/sunrpc/tst-udp-error.c
+@@ -0,0 +1,62 @@
++/* Check for use-after-free in clntudp_call (bug 21115).
++   Copyright (C) 2017 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 <netinet/in.h>
++#include <rpc/clnt.h>
++#include <rpc/svc.h>
++#include <support/check.h>
++#include <support/namespace.h>
++#include <support/xsocket.h>
++#include <unistd.h>
++
++static int
++do_test (void)
++{
++  support_become_root ();
++  support_enter_network_namespace ();
++
++  /* Obtain a likely-unused port number.  */
++  struct sockaddr_in sin =
++    {
++      .sin_family = AF_INET,
++      .sin_addr.s_addr = htonl (INADDR_LOOPBACK),
++    };
++  {
++    int fd = xsocket (AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
++    xbind (fd, (struct sockaddr *) &sin, sizeof (sin));
++    socklen_t sinlen = sizeof (sin);
++    xgetsockname (fd, (struct sockaddr *) &sin, &sinlen);
++    /* Close the socket, so that we will receive an error below.  */
++    close (fd);
++  }
++
++  int sock = RPC_ANYSOCK;
++  CLIENT *clnt = clntudp_create
++    (&sin, 1, 2, (struct timeval) { 1, 0 }, &sock);
++  TEST_VERIFY_EXIT (clnt != NULL);
++  TEST_VERIFY (clnt_call (clnt, 3,
++                          (xdrproc_t) xdr_void, NULL,
++                          (xdrproc_t) xdr_void, NULL,
++                          ((struct timeval) { 3, 0 }))
++               == RPC_CANTRECV);
++  clnt_destroy (clnt);
++
++  return 0;
++}
++
++#include <support/test-driver.c>
+diff --git a/support/Makefile b/support/Makefile
+new file mode 100644
+index 0000000000..20b0343ade
+--- /dev/null
++++ b/support/Makefile
+@@ -0,0 +1,146 @@
++# Makefile for support library, used only at build and test time
++# Copyright (C) 2016-2017 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/>.
++
++subdir := support
++
++include ../Makeconfig
++
++extra-libs := libsupport
++extra-libs-others = $(extra-libs)
++extra-libs-noinstall := $(extra-libs)
++
++libsupport-routines = \
++  check \
++  check_addrinfo \
++  check_dns_packet \
++  check_hostent \
++  check_netent \
++  delayed_exit \
++  ignore_stderr \
++  oom_error \
++  resolv_test \
++  set_fortify_handler \
++  support-xstat \
++  support_become_root \
++  support_can_chroot \
++  support_capture_subprocess \
++  support_capture_subprocess_check \
++  support_enter_network_namespace \
++  support_format_address_family \
++  support_format_addrinfo \
++  support_format_dns_packet \
++  support_format_herrno \
++  support_format_hostent \
++  support_format_netent \
++  support_isolate_in_subprocess \
++  support_record_failure \
++  support_run_diff \
++  support_shared_allocate \
++  support_write_file_string \
++  support_test_main \
++  support_test_verify_impl \
++  temp_file \
++  write_message \
++  xaccept \
++  xaccept4 \
++  xasprintf \
++  xbind \
++  xcalloc \
++  xchroot \
++  xclose \
++  xconnect \
++  xdup2 \
++  xfclose \
++  xfopen \
++  xfork \
++  xgetsockname \
++  xlisten \
++  xmalloc \
++  xmemstream \
++  xmkdir \
++  xmmap \
++  xmunmap \
++  xopen \
++  xpipe \
++  xpoll \
++  xpthread_attr_destroy \
++  xpthread_attr_init \
++  xpthread_attr_setdetachstate \
++  xpthread_attr_setstacksize \
++  xpthread_barrier_destroy \
++  xpthread_barrier_init \
++  xpthread_barrier_wait \
++  xpthread_cancel \
++  xpthread_check_return \
++  xpthread_cond_wait \
++  xpthread_create \
++  xpthread_detach \
++  xpthread_join \
++  xpthread_mutex_consistent \
++  xpthread_mutex_destroy \
++  xpthread_mutex_init \
++  xpthread_mutex_lock \
++  xpthread_mutex_unlock \
++  xpthread_mutexattr_destroy \
++  xpthread_mutexattr_init \
++  xpthread_mutexattr_setprotocol \
++  xpthread_mutexattr_setpshared \
++  xpthread_mutexattr_setrobust \
++  xpthread_mutexattr_settype \
++  xpthread_once \
++  xpthread_sigmask \
++  xpthread_spin_lock \
++  xpthread_spin_unlock \
++  xrealloc \
++  xrecvfrom \
++  xsendto \
++  xsetsockopt \
++  xsocket \
++  xstrdup \
++  xwaitpid \
++  xwrite \
++
++libsupport-static-only-routines := $(libsupport-routines)
++# Only build one variant of the library.
++libsupport-inhibit-o := .os
++ifeq ($(build-shared),yes)
++libsupport-inhibit-o += .o
++endif
++
++tests = \
++  README-testing \
++  tst-support-namespace \
++  tst-support_capture_subprocess \
++  tst-support_format_dns_packet \
++  tst-support_record_failure \
++
++ifeq ($(run-built-tests),yes)
++tests-special = \
++  $(objpfx)tst-support_record_failure-2.out
++
++$(objpfx)tst-support_record_failure-2.out: tst-support_record_failure-2.sh \
++  $(objpfx)tst-support_record_failure
++	$(SHELL) $< $(common-objpfx) '$(test-program-prefix-before-env)' \
++	  '$(run-program-env)' '$(test-program-prefix-after-env)' \
++	  > $@; \
++	$(evaluate-test)
++endif
++
++$(objpfx)tst-support_format_dns_packet: $(common-objpfx)resolv/libresolv.so
++
++include ../Rules
+diff --git a/support/README b/support/README
+new file mode 100644
+index 0000000000..476cfcda59
+--- /dev/null
++++ b/support/README
+@@ -0,0 +1,29 @@
++This subdirectory contains infrastructure which is not put into
++installed libraries, but may be linked into programs (installed or
++not) and tests.
++
++# Error-checking wrappers
++
++These wrappers test for error return codes an terminate the process on
++error.  They are declared in these header files:
++
++* support.h
++* xsignal.h
++* xthread.h
++
++In general, new wrappers should be added to support.h if possible.
++However, support.h must remain fully compatible with C90 and therefore
++cannot include headers which use identifers not reserved in C90.  If
++the wrappers need additional types, additional headers such as
++signal.h need to be introduced.
++
++# Test framework
++
++The test framework provides a main program for tests, including a
++timeout for hanging tests.  See README-testing.c for a minimal
++example, and test-driver.c for details how to use it.  The following
++header files provide related declarations:
++
++* check.h
++* temp_file.h
++* test-driver.h
+diff --git a/support/README-testing.c b/support/README-testing.c
+new file mode 100644
+index 0000000000..9d289c3020
+--- /dev/null
++++ b/support/README-testing.c
+@@ -0,0 +1,19 @@
++/* This file contains an example test case which shows minimal use of
++   the test framework.  Additional testing hooks are described in
++   <support/test-driver.c>.  */
++
++/* This function will be called from the test driver.  */
++static int
++do_test (void)
++{
++  if (3 == 5)
++    /* Indicate failure.  */
++    return 1;
++  else
++    /* Indicate success.  */
++    return 0;
++}
++
++/* This file references do_test above and contains the definition of
++   the main function.  */
++#include <support/test-driver.c>
+diff --git a/support/capture_subprocess.h b/support/capture_subprocess.h
+new file mode 100644
+index 0000000000..43caf9bce4
+--- /dev/null
++++ b/support/capture_subprocess.h
+@@ -0,0 +1,61 @@
++/* Capture output from a subprocess.
++   Copyright (C) 2017 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/>.  */
++
++#ifndef SUPPORT_CAPTURE_SUBPROCESS_H
++#define SUPPORT_CAPTURE_SUBPROCESS_H
++
++#include <support/xmemstream.h>
++
++struct support_capture_subprocess
++{
++  struct xmemstream out;
++  struct xmemstream err;
++  int status;
++};
++
++/* Invoke CALLBACK (CLOSURE) in a subprocess and capture standard
++   output, standard error, and the exit status.  The out.buffer and
++   err.buffer members in the result are null-terminated strings which
++   can be examined by the caller (out.out and err.out are NULL).  */
++struct support_capture_subprocess support_capture_subprocess
++  (void (*callback) (void *), void *closure);
++
++/* Deallocate the subprocess data captured by
++   support_capture_subprocess.  */
++void support_capture_subprocess_free (struct support_capture_subprocess *);
++
++enum support_capture_allow
++{
++  /* No output is allowed.  */
++  sc_allow_none = 0x01,
++  /* Output to stdout is permitted.  */
++  sc_allow_stdout = 0x02,
++  /* Output to standard error is permitted.  */
++  sc_allow_stderr = 0x04,
++};
++
++/* Check that the subprocess exited with STATUS and that only the
++   allowed outputs happened.  ALLOWED is a combination of
++   support_capture_allow flags.  Report errors under the CONTEXT
++   message.  */
++void support_capture_subprocess_check (struct support_capture_subprocess *,
++                                       const char *context, int status,
++                                       int allowed)
++  __attribute__ ((nonnull (1, 2)));
++
++#endif /* SUPPORT_CAPTURE_SUBPROCESS_H */
+diff --git a/support/check.c b/support/check.c
+new file mode 100644
+index 0000000000..592f2bc856
+--- /dev/null
++++ b/support/check.c
+@@ -0,0 +1,57 @@
++/* Support code for reporting test results.
++   Copyright (C) 2016-2017 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 <support/check.h>
++
++#include <stdarg.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/test-driver.h>
++
++static void
++print_failure (const char *file, int line, const char *format, va_list ap)
++{
++  printf ("error: %s:%d: ", file, line);
++  vprintf (format, ap);
++  puts ("");
++}
++
++int
++support_print_failure_impl (const char *file, int line,
++                            const char *format, ...)
++{
++  support_record_failure ();
++  va_list ap;
++  va_start (ap, format);
++  print_failure (file, line, format, ap);
++  va_end (ap);
++  return 1;
++}
++
++void
++support_exit_failure_impl (int status, const char *file, int line,
++                           const char *format, ...)
++{
++  if (status != EXIT_SUCCESS && status != EXIT_UNSUPPORTED)
++    support_record_failure ();
++  va_list ap;
++  va_start (ap, format);
++  print_failure (file, line, format, ap);
++  va_end (ap);
++  exit (status);
++}
+diff --git a/support/check.h b/support/check.h
+new file mode 100644
+index 0000000000..1d244a3557
+--- /dev/null
++++ b/support/check.h
+@@ -0,0 +1,94 @@
++/* Functionality for reporting test results.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_CHECK_H
++#define SUPPORT_CHECK_H
++
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++/* Record a test failure, print the failure message to standard output
++   and return 1.  */
++#define FAIL_RET(...) \
++  return support_print_failure_impl (__FILE__, __LINE__, __VA_ARGS__)
++
++/* Print the failure message and terminate the process with STATUS.
++   Record a the process as failed if STATUS is neither EXIT_SUCCESS
++   nor EXIT_UNSUPPORTED.  */
++#define FAIL_EXIT(status, ...) \
++  support_exit_failure_impl (status, __FILE__, __LINE__, __VA_ARGS__)
++
++/* Record a test failure, print the failure message and terminate with
++   exit status 1.  */
++#define FAIL_EXIT1(...) \
++  support_exit_failure_impl (1, __FILE__, __LINE__, __VA_ARGS__)
++
++/* Print failure message and terminate with as unsupported test (exit
++   status of 77).  */
++#define FAIL_UNSUPPORTED(...) \
++  support_exit_failure_impl (77, __FILE__, __LINE__, __VA_ARGS__)
++
++/* Record a test failure (but continue executing) if EXPR evaluates to
++   false.  */
++#define TEST_VERIFY(expr)                                       \
++  ({                                                            \
++    if (expr)                                                   \
++      ;                                                         \
++    else                                                        \
++      support_test_verify_impl (-1, __FILE__, __LINE__, #expr); \
++  })
++
++/* Record a test failure and exit if EXPR evaluates to false.  */
++#define TEST_VERIFY_EXIT(expr)                                  \
++  ({                                                            \
++    if (expr)                                                   \
++      ;                                                         \
++    else                                                        \
++      support_test_verify_impl (1, __FILE__, __LINE__, #expr);  \
++  })
++
++int support_print_failure_impl (const char *file, int line,
++                                const char *format, ...)
++  __attribute__ ((nonnull (1), format (printf, 3, 4)));
++void support_exit_failure_impl (int exit_status,
++                                const char *file, int line,
++                                const char *format, ...)
++  __attribute__ ((noreturn, nonnull (2), format (printf, 4, 5)));
++void support_test_verify_impl (int status, const char *file, int line,
++                               const char *expr);
++
++/* Record a test failure.  This function returns and does not
++   terminate the process.  The failure counter is stored in a shared
++   memory mapping, so that failures reported in child processes are
++   visible to the parent process and test driver.  This function
++   depends on initialization by an ELF constructor, so it can only be
++   invoked after the test driver has run.  Note that this function
++   does not support reporting failures from a DSO.  */
++void support_record_failure (void);
++
++/* Internal function called by the test driver.  */
++int support_report_failure (int status)
++  __attribute__ ((weak, warn_unused_result));
++
++/* Internal function used to test the failure recording framework.  */
++void support_record_failure_reset (void);
++
++__END_DECLS
++
++#endif /* SUPPORT_CHECK_H */
+diff --git a/support/check_addrinfo.c b/support/check_addrinfo.c
+new file mode 100644
+index 0000000000..55895ace3c
+--- /dev/null
++++ b/support/check_addrinfo.c
+@@ -0,0 +1,42 @@
++/* Compare struct addrinfo values against a formatted string.
++   Copyright (C) 2016-2017 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 <support/check_nss.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++#include <support/format_nss.h>
++#include <support/run_diff.h>
++
++void
++check_addrinfo (const char *query_description, struct addrinfo *ai, int ret,
++                const char *expected)
++{
++  char *formatted = support_format_addrinfo (ai, ret);
++  if (strcmp (formatted, expected) != 0)
++    {
++      support_record_failure ();
++      printf ("error: addrinfo comparison failure\n");
++      if (query_description != NULL)
++        printf ("query: %s\n", query_description);
++      support_run_diff ("expected", expected,
++                        "actual", formatted);
++    }
++  free (formatted);
++}
+diff --git a/support/check_dns_packet.c b/support/check_dns_packet.c
+new file mode 100644
+index 0000000000..d2a31bed7b
+--- /dev/null
++++ b/support/check_dns_packet.c
+@@ -0,0 +1,42 @@
++/* Check that a DNS packet buffer has the expected contents.
++   Copyright (C) 2016-2017 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 <support/check_nss.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++#include <support/format_nss.h>
++#include <support/run_diff.h>
++
++void
++check_dns_packet (const char *query_description,
++                  const unsigned char *buffer, size_t length,
++                  const char *expected)
++{
++  char *formatted = support_format_dns_packet (buffer, length);
++  if (strcmp (formatted, expected) != 0)
++    {
++      support_record_failure ();
++      printf ("error: packet comparison failure\n");
++      if (query_description != NULL)
++        printf ("query: %s\n", query_description);
++      support_run_diff ("expected", expected, "actual", formatted);
++    }
++  free (formatted);
++}
+diff --git a/support/check_hostent.c b/support/check_hostent.c
+new file mode 100644
+index 0000000000..890d672d50
+--- /dev/null
++++ b/support/check_hostent.c
+@@ -0,0 +1,42 @@
++/* Compare struct hostent values against a formatted string.
++   Copyright (C) 2016-2017 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 <support/check_nss.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++#include <support/format_nss.h>
++#include <support/run_diff.h>
++
++void
++check_hostent (const char *query_description, struct hostent *h,
++               const char *expected)
++{
++  char *formatted = support_format_hostent (h);
++  if (strcmp (formatted, expected) != 0)
++    {
++      support_record_failure ();
++      printf ("error: hostent comparison failure\n");
++      if (query_description != NULL)
++        printf ("query: %s\n", query_description);
++      support_run_diff ("expected", expected,
++                        "actual", formatted);
++    }
++  free (formatted);
++}
+diff --git a/support/check_netent.c b/support/check_netent.c
+new file mode 100644
+index 0000000000..daa3083fd1
+--- /dev/null
++++ b/support/check_netent.c
+@@ -0,0 +1,42 @@
++/* Compare struct netent values against a formatted string.
++   Copyright (C) 2016-2017 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 <support/check_nss.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++#include <support/format_nss.h>
++#include <support/run_diff.h>
++
++void
++check_netent (const char *query_description, struct netent *e,
++              const char *expected)
++{
++  char *formatted = support_format_netent (e);
++  if (strcmp (formatted, expected) != 0)
++    {
++      support_record_failure ();
++      printf ("error: netent comparison failure\n");
++      if (query_description != NULL)
++        printf ("query: %s\n", query_description);
++      support_run_diff ("expected", expected,
++                        "actual", formatted);
++    }
++  free (formatted);
++}
+diff --git a/support/check_nss.h b/support/check_nss.h
+new file mode 100644
+index 0000000000..2893f2c295
+--- /dev/null
++++ b/support/check_nss.h
+@@ -0,0 +1,42 @@
++/* Test verification functions for NSS- and DNS-related data.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_CHECK_NSS_H
++#define SUPPORT_CHECK_NSS_H
++
++#include <netdb.h>
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++/* Compare the data structures against the expected values (which have
++   to be formatted according to the support_format_* functions in
++   <support/format_nss.h>).  If there is a difference, a delayed test
++   failure is recorded, and a diff is written to standard output.  */
++void check_addrinfo (const char *query_description,
++                     struct addrinfo *, int ret, const char *expected);
++void check_dns_packet (const char *query_description,
++                       const unsigned char *, size_t, const char *expected);
++void check_hostent (const char *query_description,
++                    struct hostent *, const char *expected);
++void check_netent (const char *query_description,
++                   struct netent *, const char *expected);
++
++__END_DECLS
++
++#endif  /* SUPPORT_CHECK_NSS_H */
+diff --git a/support/delayed_exit.c b/support/delayed_exit.c
+new file mode 100644
+index 0000000000..67442f95df
+--- /dev/null
++++ b/support/delayed_exit.c
+@@ -0,0 +1,55 @@
++/* Time-triggered process termination.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++#include <support/xsignal.h>
++
++#include <stdint.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++#include <time.h>
++
++static void *
++delayed_exit_thread (void *seconds_as_ptr)
++{
++  int seconds = (uintptr_t) seconds_as_ptr;
++  struct timespec delay = { seconds, 0 };
++  struct timespec remaining = { 0 };
++  if (nanosleep (&delay, &remaining) != 0)
++    FAIL_EXIT1 ("nanosleep: %m");
++  /* Exit the process sucessfully.  */
++  exit (0);
++  return NULL;
++}
++
++void
++delayed_exit (int seconds)
++{
++  /* Create the new thread with all signals blocked.  */
++  sigset_t all_blocked;
++  sigfillset (&all_blocked);
++  sigset_t old_set;
++  xpthread_sigmask (SIG_SETMASK, &all_blocked, &old_set);
++  /* Create a detached thread. */
++  pthread_t thr = xpthread_create
++    (NULL, delayed_exit_thread, (void *) (uintptr_t) seconds);
++  xpthread_detach (thr);
++  /* Restore the original signal mask.  */
++  xpthread_sigmask (SIG_SETMASK, &old_set, NULL);
++}
+diff --git a/support/format_nss.h b/support/format_nss.h
+new file mode 100644
+index 0000000000..fb4597c238
+--- /dev/null
++++ b/support/format_nss.h
+@@ -0,0 +1,41 @@
++/* String formatting functions for NSS- and DNS-related data.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_FORMAT_NSS_H
++#define SUPPORT_FORMAT_NSS_H
++
++#include <netdb.h>
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++/* The following functions format their arguments as human-readable
++   strings (which can span multiple lines).  The caller must free the
++   returned buffer.  For NULL pointers or failure status arguments,
++   error variables such as h_errno and errno are included in the
++   result.  */
++char *support_format_address_family (int);
++char *support_format_addrinfo (struct addrinfo *, int ret);
++char *support_format_dns_packet (const unsigned char *buffer, size_t length);
++char *support_format_herrno (int);
++char *support_format_hostent (struct hostent *);
++char *support_format_netent (struct netent *);
++
++__END_DECLS
++
++#endif  /* SUPPORT_FORMAT_NSS_H */
+diff --git a/support/ignore_stderr.c b/support/ignore_stderr.c
+new file mode 100644
+index 0000000000..7b77a2cd56
+--- /dev/null
++++ b/support/ignore_stderr.c
+@@ -0,0 +1,38 @@
++/* Avoid all the buffer overflow messages on stderr.
++   Copyright (C) 2015-2017 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 <support/support.h>
++
++#include <fcntl.h>
++#include <paths.h>
++#include <stdlib.h>
++#include <unistd.h>
++
++void
++ignore_stderr (void)
++{
++  int fd = open (_PATH_DEVNULL, O_WRONLY);
++  if (fd == -1)
++    close (STDERR_FILENO);
++  else
++    {
++      dup2 (fd, STDERR_FILENO);
++      close (fd);
++    }
++  setenv ("LIBC_FATAL_STDERR_", "1", 1);
++}
+diff --git a/support/namespace.h b/support/namespace.h
+new file mode 100644
+index 0000000000..e1ccaa1ef0
+--- /dev/null
++++ b/support/namespace.h
+@@ -0,0 +1,65 @@
++/* Entering namespaces for test case isolation.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_NAMESPACE_H
++#define SUPPORT_NAMESPACE_H
++
++#include <stdbool.h>
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++/* Attempts to become root (or acquire root-like privileges), possibly
++   with the help of user namespaces.  Return true if (restricted) root
++   privileges could be attained in some way.  Print diagnostics to
++   standard output.
++
++   Note that this function generally has to be called before a process
++   becomes multi-threaded, otherwise it may fail with insufficient
++   privileges on systems which would support this operation for
++   single-threaded processes.  */
++bool support_become_root (void);
++
++/* Return true if this process can perform a chroot operation.  In
++   general, this is only possible if support_become_root has been
++   called.  Note that the actual test is performed in a subprocess,
++   after fork, so that the file system root of the original process is
++   not changed.  */
++bool support_can_chroot (void);
++
++/* Enter a network namespace (and a UTS namespace if possible) and
++   configure the loopback interface.  Return true if a network
++   namespace could be created.  Print diagnostics to standard output.
++   If a network namespace could be created, but networking in it could
++   not be configured, terminate the process.  It is recommended to
++   call support_become_root before this function so that the process
++   has sufficient privileges.  */
++bool support_enter_network_namespace (void);
++
++/* Return true if support_enter_network_namespace managed to enter a
++   UTS namespace.  */
++bool support_in_uts_namespace (void);
++
++/* Invoke CALLBACK (CLOSURE) in a subprocess created using fork.
++   Terminate the calling process if the subprocess exits with a
++   non-zero exit status.  */
++void support_isolate_in_subprocess (void (*callback) (void *), void *closure);
++
++__END_DECLS
++
++#endif
+diff --git a/sysdeps/sparc/sparc64/fpu/s_fdimf.S b/support/oom_error.c
+similarity index 69%
+rename from sysdeps/sparc/sparc64/fpu/s_fdimf.S
+rename to support/oom_error.c
+index 356c23c4e3..7816978273 100644
+--- a/sysdeps/sparc/sparc64/fpu/s_fdimf.S
++++ b/support/oom_error.c
+@@ -1,7 +1,6 @@
+-/* Compute positive difference, sparc 64-bit.
+-   Copyright (C) 2013-2016 Free Software Foundation, Inc.
++/* Reporting out-of-memory errors.
++   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by David S. Miller <davem@davemloft.net>.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -17,15 +16,14 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-#include <sysdep.h>
++#include <support/support.h>
+ 
+-ENTRY(__fdimf)
+-	fcmps	%f1, %f3
+-	fbug	1f
+-	 nop
+-	fzeros	%f1
+-	fnegs	%f1, %f3
+-1:	retl
+-	 fsubs	%f1, %f3, %f0
+-END(__fdimf)
+-weak_alias (__fdimf, fdimf)
++#include <stdio.h>
++#include <stdlib.h>
++
++void
++oom_error (const char *function, size_t size)
++{
++  printf ("%s: unable to allocate %zu bytes: %m\n", function, size);
++  exit (1);
++}
+diff --git a/support/resolv_test.c b/support/resolv_test.c
+new file mode 100644
+index 0000000000..050cd7154b
+--- /dev/null
++++ b/support/resolv_test.c
+@@ -0,0 +1,1202 @@
++/* DNS test framework and libresolv redirection.
++   Copyright (C) 2016-2017 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 <support/resolv_test.h>
++
++#include <arpa/inet.h>
++#include <errno.h>
++#include <fcntl.h>
++#include <nss.h>
++#include <resolv.h>
++#include <search.h>
++#include <stdlib.h>
++#include <string.h>
++#include <support/check.h>
++#include <support/namespace.h>
++#include <support/support.h>
++#include <support/test-driver.h>
++#include <support/xsocket.h>
++#include <support/xthread.h>
++#include <support/xunistd.h>
++#include <sys/uio.h>
++#include <unistd.h>
++
++/* Response builder.  */
++
++enum
++  {
++    max_response_length = 65536
++  };
++
++/* List of pointers to be freed.  The hash table implementation
++   (struct hsearch_data) does not provide a way to deallocate all
++   objects, so this approach is used to avoid memory leaks.  */
++struct to_be_freed
++{
++  struct to_be_freed *next;
++  void *ptr;
++};
++
++struct resolv_response_builder
++{
++  const unsigned char *query_buffer;
++  size_t query_length;
++
++  size_t offset;                /* Bytes written so far in buffer.  */
++  ns_sect section;              /* Current section in the DNS packet.  */
++  unsigned int truncate_bytes;  /* Bytes to remove at end of response. */
++  bool drop;                    /* Discard generated response.  */
++  bool close;                   /* Close TCP client connection.  */
++
++  /* Offset of the two-byte RDATA length field in the currently
++     written RDATA sub-structure.  0 if no RDATA is being written.  */
++  size_t current_rdata_offset;
++
++  /* Hash table for locating targets for label compression.  */
++  struct hsearch_data compression_offsets;
++  /* List of pointers which need to be freed.  Used for domain names
++     involved in label compression.  */
++  struct to_be_freed *to_be_freed;
++
++  /* Must be last.  Not zeroed for performance reasons.  */
++  unsigned char buffer[max_response_length];
++};
++
++/* Response builder. */
++
++/* Add a pointer to the list of pointers to be freed when B is
++   deallocated.  */
++static void
++response_push_pointer_to_free (struct resolv_response_builder *b, void *ptr)
++{
++  if (ptr == NULL)
++    return;
++  struct to_be_freed *e = xmalloc (sizeof (*e));
++  *e = (struct to_be_freed) {b->to_be_freed, ptr};
++  b->to_be_freed = e;
++}
++
++void
++resolv_response_init (struct resolv_response_builder *b,
++                      struct resolv_response_flags flags)
++{
++  if (b->offset > 0)
++    FAIL_EXIT1 ("response_init: called at offset %zu", b->offset);
++  if (b->query_length < 12)
++    FAIL_EXIT1 ("response_init called for a query of size %zu",
++                b->query_length);
++  if (flags.rcode > 15)
++    FAIL_EXIT1 ("response_init: invalid RCODE %u", flags.rcode);
++
++  /* Copy the transaction ID.  */
++  b->buffer[0] = b->query_buffer[0];
++  b->buffer[1] = b->query_buffer[1];
++
++  /* Initialize the flags.  */
++  b->buffer[2] = 0x80;                       /* Mark as response.   */
++  b->buffer[2] |= b->query_buffer[2] & 0x01; /* Copy the RD bit.  */
++  if (flags.tc)
++    b->buffer[2] |= 0x02;
++  b->buffer[3] = 0x80 | flags.rcode; /* Always set RA.  */
++
++  /* Fill in the initial section count values.  */
++  b->buffer[4] = flags.qdcount >> 8;
++  b->buffer[5] = flags.qdcount;
++  b->buffer[6] = flags.ancount >> 8;
++  b->buffer[7] = flags.ancount;
++  b->buffer[8] = flags.nscount >> 8;
++  b->buffer[9] = flags.nscount;
++  b->buffer[10] = flags.adcount >> 8;
++  b->buffer[11] = flags.adcount;
++
++  b->offset = 12;
++}
++
++void
++resolv_response_section (struct resolv_response_builder *b, ns_sect section)
++{
++  if (b->offset == 0)
++    FAIL_EXIT1 ("resolv_response_section: response_init not called before");
++  if (section < b->section)
++    FAIL_EXIT1 ("resolv_response_section: cannot go back to previous section");
++  b->section = section;
++}
++
++/* Add a single byte to B.  */
++static inline void
++response_add_byte (struct resolv_response_builder *b, unsigned char ch)
++{
++  if (b->offset == max_response_length)
++    FAIL_EXIT1 ("DNS response exceeds 64 KiB limit");
++  b->buffer[b->offset] = ch;
++  ++b->offset;
++}
++
++/* Add a 16-bit word VAL to B, in big-endian format.  */
++static void
++response_add_16 (struct resolv_response_builder *b, uint16_t val)
++{
++  response_add_byte (b, val >> 8);
++  response_add_byte (b, val);
++}
++
++/* Increment the pers-section record counter in the packet header.  */
++static void
++response_count_increment (struct resolv_response_builder *b)
++{
++  unsigned int offset = b->section;
++  offset = 4 + 2 * offset;
++  ++b->buffer[offset + 1];
++  if (b->buffer[offset + 1] == 0)
++    {
++      /* Carry.  */
++      ++b->buffer[offset];
++      if (b->buffer[offset] == 0)
++        /* Overflow.  */
++        FAIL_EXIT1 ("too many records in section");
++    }
++}
++
++void
++resolv_response_add_question (struct resolv_response_builder *b,
++                              const char *name, uint16_t class, uint16_t type)
++{
++  if (b->offset == 0)
++    FAIL_EXIT1 ("resolv_response_add_question: "
++                "resolv_response_init not called");
++  if (b->section != ns_s_qd)
++    FAIL_EXIT1 ("resolv_response_add_question: "
++                "must be called in the question section");
++
++  resolv_response_add_name (b, name);
++  response_add_16 (b, type);
++  response_add_16 (b, class);
++
++  response_count_increment (b);
++}
++
++void
++resolv_response_add_name (struct resolv_response_builder *b,
++                          const char *const origname)
++{
++  /* Normalized name.  */
++  char *name;
++  /* Normalized name with case preserved.  */
++  char *name_case;
++  {
++    size_t namelen = strlen (origname);
++    /* Remove trailing dots.  FIXME: Handle trailing quoted dots.  */
++    while (namelen > 0 && origname[namelen - 1] == '.')
++      --namelen;
++    name = xmalloc (namelen + 1);
++    name_case = xmalloc (namelen + 1);
++    /* Copy and convert to lowercase.  FIXME: This needs to normalize
++       escaping as well.  */
++    for (size_t i = 0; i < namelen; ++i)
++      {
++        char ch = origname[i];
++        name_case[i] = ch;
++        if ('A' <= ch && ch <= 'Z')
++          ch = ch - 'A' + 'a';
++        name[i] = ch;
++      }
++    name[namelen] = 0;
++    name_case[namelen] = 0;
++  }
++  char *name_start = name;
++  char *name_case_start = name_case;
++
++  bool compression = false;
++  while (*name)
++    {
++      /* Search for a previous name we can reference.  */
++      ENTRY new_entry =
++        {
++          .key = name,
++          .data = (void *) (uintptr_t) b->offset,
++        };
++
++      /* If the label can be a compression target because it is at a
++         reachable offset, add it to the hash table.  */
++      ACTION action;
++      if (b->offset < (1 << 12))
++        action = ENTER;
++      else
++        action = FIND;
++
++      /* Search for known compression offsets in the hash table.  */
++      ENTRY *e;
++      if (hsearch_r (new_entry, action, &e, &b->compression_offsets) == 0)
++        {
++          if (action == FIND && errno == ESRCH)
++            /* Fall through.  */
++            e = NULL;
++          else
++            FAIL_EXIT1 ("hsearch_r failure in name compression: %m");
++        }
++
++      /* The name is known.  Reference the previous location.  */
++      if (e != NULL && e->data != new_entry.data)
++        {
++          size_t old_offset = (uintptr_t) e->data;
++          response_add_byte (b, 0xC0 | (old_offset >> 8));
++          response_add_byte (b, old_offset);
++          compression = true;
++          break;
++        }
++
++      /* The name does not exist yet.  Write one label.  First, add
++         room for the label length.  */
++      size_t buffer_label_offset = b->offset;
++      response_add_byte (b, 0);
++
++      /* Copy the label.  */
++      while (true)
++        {
++          char ch = *name_case;
++          if (ch == '\0')
++            break;
++          ++name;
++          ++name_case;
++          if (ch == '.')
++            break;
++          /* FIXME: Handle escaping.  */
++          response_add_byte (b, ch);
++        }
++
++      /* Patch in the label length.  */
++      size_t label_length = b->offset - buffer_label_offset - 1;
++      if (label_length == 0)
++        FAIL_EXIT1 ("empty label in name compression: %s", origname);
++      if (label_length > 63)
++        FAIL_EXIT1 ("label too long in name compression: %s", origname);
++      b->buffer[buffer_label_offset] = label_length;
++
++      /* Continue with the tail of the name and the next label.  */
++    }
++
++  if (compression)
++    {
++      /* If we found an immediate match for the name, we have not put
++         it into the hash table, and can free it immediately.  */
++      if (name == name_start)
++        free (name_start);
++      else
++        response_push_pointer_to_free (b, name_start);
++    }
++  else
++    {
++      /* Terminate the sequence of labels.  With compression, this is
++         implicit in the compression reference.  */
++      response_add_byte (b, 0);
++      response_push_pointer_to_free (b, name_start);
++    }
++
++  free (name_case_start);
++}
++
++void
++resolv_response_open_record (struct resolv_response_builder *b,
++                             const char *name,
++                             uint16_t class, uint16_t type, uint32_t ttl)
++{
++  if (b->section == ns_s_qd)
++    FAIL_EXIT1 ("resolv_response_open_record called in question section");
++  if (b->current_rdata_offset != 0)
++    FAIL_EXIT1 ("resolv_response_open_record called with open record");
++
++  resolv_response_add_name (b, name);
++  response_add_16 (b, type);
++  response_add_16 (b, class);
++  response_add_16 (b, ttl >> 16);
++  response_add_16 (b, ttl);
++
++  b->current_rdata_offset = b->offset;
++  /* Add room for the RDATA length.  */
++  response_add_16 (b, 0);
++}
++
++
++void
++resolv_response_close_record (struct resolv_response_builder *b)
++{
++  size_t rdata_offset = b->current_rdata_offset;
++  if (rdata_offset == 0)
++    FAIL_EXIT1 ("response_close_record called without open record");
++  size_t rdata_length = b->offset - rdata_offset - 2;
++  if (rdata_length > 65535)
++    FAIL_EXIT1 ("RDATA length %zu exceeds limit", rdata_length);
++  b->buffer[rdata_offset] = rdata_length >> 8;
++  b->buffer[rdata_offset + 1] = rdata_length;
++  response_count_increment (b);
++  b->current_rdata_offset = 0;
++}
++
++void
++resolv_response_add_data (struct resolv_response_builder *b,
++                          const void *data, size_t length)
++{
++  size_t remaining = max_response_length - b->offset;
++  if (remaining < length)
++    FAIL_EXIT1 ("resolv_response_add_data: not enough room for %zu bytes",
++                length);
++  memcpy (b->buffer + b->offset, data, length);
++  b->offset += length;
++}
++
++void
++resolv_response_drop (struct resolv_response_builder *b)
++{
++  b->drop = true;
++}
++
++void
++resolv_response_close (struct resolv_response_builder *b)
++{
++  b->close = true;
++}
++
++void
++resolv_response_truncate_data (struct resolv_response_builder *b, size_t count)
++{
++  if (count > 65535)
++    FAIL_EXIT1 ("resolv_response_truncate_data: argument too large: %zu",
++                count);
++  b->truncate_bytes = count;
++}
++
++
++size_t
++resolv_response_length (const struct resolv_response_builder *b)
++{
++  return b->offset;
++}
++
++unsigned char *
++resolv_response_buffer (const struct resolv_response_builder *b)
++{
++  unsigned char *result = xmalloc (b->offset);
++  memcpy (result, b->buffer, b->offset);
++  return result;
++}
++
++static struct resolv_response_builder *
++response_builder_allocate
++  (const unsigned char *query_buffer, size_t query_length)
++{
++  struct resolv_response_builder *b = xmalloc (sizeof (*b));
++  memset (b, 0, offsetof (struct resolv_response_builder, buffer));
++  b->query_buffer = query_buffer;
++  b->query_length = query_length;
++  TEST_VERIFY_EXIT (hcreate_r (10000, &b->compression_offsets) != 0);
++  return b;
++}
++
++static void
++response_builder_free (struct resolv_response_builder *b)
++{
++  struct to_be_freed *current = b->to_be_freed;
++  while (current != NULL)
++    {
++      struct to_be_freed *next = current->next;
++      free (current->ptr);
++      free (current);
++      current = next;
++    }
++  hdestroy_r (&b->compression_offsets);
++  free (b);
++}
++
++/* DNS query processing. */
++
++/* Data extracted from the question section of a DNS packet.  */
++struct query_info
++{
++  char qname[MAXDNAME];
++  uint16_t qclass;
++  uint16_t qtype;
++  struct resolv_edns_info edns;
++};
++
++/* Update *INFO from the specified DNS packet.  */
++static void
++parse_query (struct query_info *info,
++             const unsigned char *buffer, size_t length)
++{
++  HEADER hd;
++  _Static_assert (sizeof (hd) == 12, "DNS header size");
++  if (length < sizeof (hd))
++    FAIL_EXIT1 ("malformed DNS query: too short: %zu bytes", length);
++  memcpy (&hd, buffer, sizeof (hd));
++
++  if (ntohs (hd.qdcount) != 1)
++    FAIL_EXIT1 ("malformed DNS query: wrong question count: %d",
++                (int) ntohs (hd.qdcount));
++  if (ntohs (hd.ancount) != 0)
++    FAIL_EXIT1 ("malformed DNS query: wrong answer count: %d",
++                (int) ntohs (hd.ancount));
++  if (ntohs (hd.nscount) != 0)
++    FAIL_EXIT1 ("malformed DNS query: wrong authority count: %d",
++                (int) ntohs (hd.nscount));
++  if (ntohs (hd.arcount) > 1)
++    FAIL_EXIT1 ("malformed DNS query: wrong additional count: %d",
++                (int) ntohs (hd.arcount));
++
++  int ret = dn_expand (buffer, buffer + length, buffer + sizeof (hd),
++                       info->qname, sizeof (info->qname));
++  if (ret < 0)
++    FAIL_EXIT1 ("malformed DNS query: cannot uncompress QNAME");
++
++  /* Obtain QTYPE and QCLASS.  */
++  size_t remaining = length - (12 + ret);
++  struct
++  {
++    uint16_t qtype;
++    uint16_t qclass;
++  } qtype_qclass;
++  if (remaining < sizeof (qtype_qclass))
++    FAIL_EXIT1 ("malformed DNS query: "
++                "query lacks QCLASS/QTYPE, QNAME: %s", info->qname);
++  memcpy (&qtype_qclass, buffer + 12 + ret, sizeof (qtype_qclass));
++  info->qclass = ntohs (qtype_qclass.qclass);
++  info->qtype = ntohs (qtype_qclass.qtype);
++
++  memset (&info->edns, 0, sizeof (info->edns));
++  if (ntohs (hd.arcount) > 0)
++    {
++      /* Parse EDNS record.  */
++      struct __attribute__ ((packed, aligned (1)))
++      {
++        uint8_t root;
++        uint16_t rtype;
++        uint16_t payload;
++        uint8_t edns_extended_rcode;
++        uint8_t edns_version;
++        uint16_t flags;
++        uint16_t rdatalen;
++      } rr;
++      _Static_assert (sizeof (rr) == 11, "EDNS record size");
++
++      if (remaining < 4 + sizeof (rr))
++        FAIL_EXIT1 ("mailformed DNS query: no room for EDNS record");
++      memcpy (&rr, buffer + 12 + ret + 4, sizeof (rr));
++      if (rr.root != 0)
++        FAIL_EXIT1 ("malformed DNS query: invalid OPT RNAME: %d\n", rr.root);
++      if (rr.rtype != htons (41))
++        FAIL_EXIT1 ("malformed DNS query: invalid OPT type: %d\n",
++                    ntohs (rr.rtype));
++      info->edns.active = true;
++      info->edns.extended_rcode = rr.edns_extended_rcode;
++      info->edns.version = rr.edns_version;
++      info->edns.flags = ntohs (rr.flags);
++      info->edns.payload_size = ntohs (rr.payload);
++    }
++}
++
++
++/* Main testing framework.  */
++
++/* Per-server information.  One struct is allocated for each test
++   server.  */
++struct resolv_test_server
++{
++  /* Local address of the server.  UDP and TCP use the same port.  */
++  struct sockaddr_in address;
++
++  /* File descriptor of the UDP server, or -1 if this server is
++     disabled.  */
++  int socket_udp;
++
++  /* File descriptor of the TCP server, or -1 if this server is
++     disabled.  */
++  int socket_tcp;
++
++  /* Counter of the number of responses processed so far.  */
++  size_t response_number;
++
++  /* Thread handles for the server threads (if not disabled in the
++     configuration).  */
++  pthread_t thread_udp;
++  pthread_t thread_tcp;
++};
++
++/* Main struct for keeping track of libresolv redirection and
++   testing.  */
++struct resolv_test
++{
++  /* After initialization, any access to the struct must be performed
++     while this lock is acquired.  */
++  pthread_mutex_t lock;
++
++  /* Data for each test server. */
++  struct resolv_test_server servers[resolv_max_test_servers];
++
++  /* Used if config.single_thread_udp is true.  */
++  pthread_t thread_udp_single;
++
++  struct resolv_redirect_config config;
++  bool termination_requested;
++};
++
++/* Function implementing a server thread.  */
++typedef void (*thread_callback) (struct resolv_test *, int server_index);
++
++/* Storage for thread-specific data, for passing to the
++   thread_callback function.  */
++struct thread_closure
++{
++  struct resolv_test *obj;      /* Current test object.  */
++  thread_callback callback;     /* Function to call.  */
++  int server_index;             /* Index of the implemented server.  */
++};
++
++/* Wrap response_callback as a function which can be passed to
++   pthread_create.  */
++static void *
++thread_callback_wrapper (void *arg)
++{
++  struct thread_closure *closure = arg;
++  closure->callback (closure->obj, closure->server_index);
++  free (closure);
++  return NULL;
++}
++
++/* Start a server thread for the specified SERVER_INDEX, implemented
++   by CALLBACK.  */
++static pthread_t
++start_server_thread (struct resolv_test *obj, int server_index,
++                     thread_callback callback)
++{
++  struct thread_closure *closure = xmalloc (sizeof (*closure));
++  *closure = (struct thread_closure)
++    {
++      .obj = obj,
++      .callback = callback,
++      .server_index = server_index,
++    };
++  return xpthread_create (NULL, thread_callback_wrapper, closure);
++}
++
++/* Process one UDP query.  Return false if a termination requested has
++   been detected.  */
++static bool
++server_thread_udp_process_one (struct resolv_test *obj, int server_index)
++{
++  unsigned char query[512];
++  struct sockaddr_storage peer;
++  socklen_t peerlen = sizeof (peer);
++  size_t length = xrecvfrom (obj->servers[server_index].socket_udp,
++                             query, sizeof (query), 0,
++                             (struct sockaddr *) &peer, &peerlen);
++  /* Check for termination.  */
++  {
++    bool termination_requested;
++    xpthread_mutex_lock (&obj->lock);
++    termination_requested = obj->termination_requested;
++    xpthread_mutex_unlock (&obj->lock);
++    if (termination_requested)
++      return false;
++  }
++
++
++  struct query_info qinfo;
++  parse_query (&qinfo, query, length);
++  if (test_verbose > 0)
++    {
++      if (test_verbose > 1)
++        printf ("info: UDP server %d: incoming query:"
++                " %zd bytes, %s/%u/%u, tnxid=0x%02x%02x\n",
++                server_index, length, qinfo.qname, qinfo.qclass, qinfo.qtype,
++                query[0], query[1]);
++      else
++        printf ("info: UDP server %d: incoming query:"
++                " %zd bytes, %s/%u/%u\n",
++                server_index, length, qinfo.qname, qinfo.qclass, qinfo.qtype);
++    }
++
++  struct resolv_response_context ctx =
++    {
++      .query_buffer = query,
++      .query_length = length,
++      .server_index = server_index,
++      .tcp = false,
++      .edns = qinfo.edns,
++    };
++  struct resolv_response_builder *b = response_builder_allocate (query, length);
++  obj->config.response_callback
++    (&ctx, b, qinfo.qname, qinfo.qclass, qinfo.qtype);
++
++  if (b->drop)
++    {
++      if (test_verbose)
++        printf ("info: UDP server %d: dropping response to %s/%u/%u\n",
++                server_index, qinfo.qname, qinfo.qclass, qinfo.qtype);
++    }
++  else
++    {
++      if (test_verbose)
++        {
++          if (b->offset >= 12)
++            printf ("info: UDP server %d: sending response:"
++                    " %zu bytes, RCODE %d (for %s/%u/%u)\n",
++                    server_index, b->offset, b->buffer[3] & 0x0f,
++                    qinfo.qname, qinfo.qclass, qinfo.qtype);
++          else
++            printf ("info: UDP server %d: sending response: %zu bytes"
++                    " (for %s/%u/%u)\n",
++                    server_index, b->offset,
++                    qinfo.qname, qinfo.qclass, qinfo.qtype);
++          if (b->truncate_bytes > 0)
++            printf ("info:    truncated by %u bytes\n", b->truncate_bytes);
++        }
++      size_t to_send = b->offset;
++      if (to_send < b->truncate_bytes)
++        to_send = 0;
++      else
++        to_send -= b->truncate_bytes;
++
++      /* Ignore most errors here because the other end may have closed
++         the socket. */
++      if (sendto (obj->servers[server_index].socket_udp,
++                  b->buffer, to_send, 0,
++                  (struct sockaddr *) &peer, peerlen) < 0)
++        TEST_VERIFY_EXIT (errno != EBADF);
++    }
++  response_builder_free (b);
++  return true;
++}
++
++/* UDP thread_callback function.  Variant for one thread per
++   server.  */
++static void
++server_thread_udp (struct resolv_test *obj, int server_index)
++{
++  while (server_thread_udp_process_one (obj, server_index))
++    ;
++}
++
++/* Single-threaded UDP processing function, for the single_thread_udp
++   case.  */
++static void *
++server_thread_udp_single (void *closure)
++{
++  struct resolv_test *obj = closure;
++
++  struct pollfd fds[resolv_max_test_servers];
++  for (int server_index = 0; server_index < resolv_max_test_servers;
++       ++server_index)
++    if (obj->config.servers[server_index].disable_udp)
++      fds[server_index] = (struct pollfd) {.fd = -1};
++    else
++      {
++        fds[server_index] = (struct pollfd)
++          {
++            .fd = obj->servers[server_index].socket_udp,
++            .events = POLLIN
++          };
++
++        /* Make the socket non-blocking.  */
++        int flags = fcntl (obj->servers[server_index].socket_udp, F_GETFL, 0);
++        if (flags < 0)
++          FAIL_EXIT1 ("fcntl (F_GETFL): %m");
++        flags |= O_NONBLOCK;
++        if (fcntl (obj->servers[server_index].socket_udp, F_SETFL, flags) < 0)
++          FAIL_EXIT1 ("fcntl (F_SETFL): %m");
++      }
++
++  while (true)
++    {
++      xpoll (fds, resolv_max_test_servers, -1);
++      for (int server_index = 0; server_index < resolv_max_test_servers;
++           ++server_index)
++        if (fds[server_index].revents != 0)
++          {
++            if (!server_thread_udp_process_one (obj, server_index))
++              goto out;
++            fds[server_index].revents = 0;
++          }
++    }
++
++ out:
++  return NULL;
++}
++
++/* Start the single UDP handler thread (for the single_thread_udp
++   case).  */
++static void
++start_server_thread_udp_single (struct resolv_test *obj)
++{
++  obj->thread_udp_single
++    = xpthread_create (NULL, server_thread_udp_single, obj);
++}
++
++/* Data describing a TCP client connect.  */
++struct tcp_thread_closure
++{
++  struct resolv_test *obj;
++  int server_index;
++  int client_socket;
++};
++
++/* Read a complete DNS query packet.  If EOF_OK, an immediate
++   end-of-file condition is acceptable.  */
++static bool
++read_fully (int fd, void *buf, size_t len, bool eof_ok)
++{
++  const void *const end = buf + len;
++  while (buf < end)
++    {
++      ssize_t ret = read (fd, buf, end - buf);
++      if (ret == 0)
++        {
++          if (!eof_ok)
++            {
++              support_record_failure ();
++              printf ("error: unexpected EOF on TCP connection\n");
++            }
++          return false;
++        }
++      else if (ret < 0)
++        {
++          if (!eof_ok || errno != ECONNRESET)
++            {
++              support_record_failure ();
++              printf ("error: TCP read: %m\n");
++            }
++          return false;
++        }
++      buf += ret;
++      eof_ok = false;
++    }
++  return true;
++}
++
++/* Write an array of iovecs.  Terminate the process on failure.  */
++static void
++writev_fully (int fd, struct iovec *buffers, size_t count)
++{
++  while (count > 0)
++    {
++      /* Skip zero-length write requests.  */
++      if (buffers->iov_len == 0)
++        {
++          ++buffers;
++          --count;
++          continue;
++        }
++      /* Try to rewrite the remaing buffers.  */
++      ssize_t ret = writev (fd, buffers, count);
++      if (ret < 0)
++        FAIL_EXIT1 ("writev: %m");
++      if (ret == 0)
++        FAIL_EXIT1 ("writev: invalid return value zero");
++      /* Find the buffers that were successfully written.  */
++      while (ret > 0)
++        {
++          if (count == 0)
++            FAIL_EXIT1 ("internal writev consistency failure");
++          /* Current buffer was partially written.  */
++          if (buffers->iov_len > (size_t) ret)
++            {
++              buffers->iov_base += ret;
++              buffers->iov_len -= ret;
++              ret = 0;
++            }
++          else
++            {
++              ret -= buffers->iov_len;
++              buffers->iov_len = 0;
++              ++buffers;
++              --count;
++            }
++        }
++    }
++}
++
++/* Thread callback for handling a single established TCP connection to
++   a client.  */
++static void *
++server_thread_tcp_client (void *arg)
++{
++  struct tcp_thread_closure *closure = arg;
++
++  while (true)
++    {
++      /* Read packet length.  */
++      uint16_t query_length;
++      if (!read_fully (closure->client_socket,
++                       &query_length, sizeof (query_length), true))
++        break;
++      query_length = ntohs (query_length);
++
++      /* Read the packet.  */
++      unsigned char *query_buffer = xmalloc (query_length);
++      read_fully (closure->client_socket, query_buffer, query_length, false);
++
++      struct query_info qinfo;
++      parse_query (&qinfo, query_buffer, query_length);
++      if (test_verbose > 0)
++        {
++          if (test_verbose > 1)
++            printf ("info: UDP server %d: incoming query:"
++                    " %d bytes, %s/%u/%u, tnxid=0x%02x%02x\n",
++                    closure->server_index, query_length,
++                    qinfo.qname, qinfo.qclass, qinfo.qtype,
++                    query_buffer[0], query_buffer[1]);
++          else
++            printf ("info: TCP server %d: incoming query:"
++                    " %u bytes, %s/%u/%u\n",
++                    closure->server_index, query_length,
++                    qinfo.qname, qinfo.qclass, qinfo.qtype);
++        }
++
++      struct resolv_response_context ctx =
++        {
++          .query_buffer = query_buffer,
++          .query_length = query_length,
++          .server_index = closure->server_index,
++          .tcp = true,
++          .edns = qinfo.edns,
++        };
++      struct resolv_response_builder *b = response_builder_allocate
++        (query_buffer, query_length);
++      closure->obj->config.response_callback
++        (&ctx, b, qinfo.qname, qinfo.qclass, qinfo.qtype);
++
++      if (b->drop)
++        {
++          if (test_verbose)
++            printf ("info: TCP server %d: dropping response to %s/%u/%u\n",
++                    closure->server_index,
++                    qinfo.qname, qinfo.qclass, qinfo.qtype);
++        }
++      else
++        {
++          if (test_verbose)
++            printf ("info: TCP server %d: sending response: %zu bytes"
++                    " (for %s/%u/%u)\n",
++                    closure->server_index, b->offset,
++                    qinfo.qname, qinfo.qclass, qinfo.qtype);
++          uint16_t length = htons (b->offset);
++          size_t to_send = b->offset;
++          if (to_send < b->truncate_bytes)
++            to_send = 0;
++          else
++            to_send -= b->truncate_bytes;
++          struct iovec buffers[2] =
++            {
++              {&length, sizeof (length)},
++              {b->buffer, to_send}
++            };
++          writev_fully (closure->client_socket, buffers, 2);
++        }
++      bool close_flag = b->close;
++      response_builder_free (b);
++      free (query_buffer);
++      if (close_flag)
++        break;
++    }
++
++  xclose (closure->client_socket);
++  free (closure);
++  return NULL;
++}
++
++/* thread_callback for the TCP case.  Accept connections and create a
++   new thread for each client.  */
++static void
++server_thread_tcp (struct resolv_test *obj, int server_index)
++{
++  while (true)
++    {
++      /* Get the client conenction.  */
++      int client_socket = xaccept
++        (obj->servers[server_index].socket_tcp, NULL, NULL);
++
++      /* Check for termination.  */
++      xpthread_mutex_lock (&obj->lock);
++      if (obj->termination_requested)
++        {
++          xpthread_mutex_unlock (&obj->lock);
++          xclose (client_socket);
++          break;
++        }
++      xpthread_mutex_unlock (&obj->lock);
++
++      /* Spawn a new thread for handling this connection.  */
++      struct tcp_thread_closure *closure = xmalloc (sizeof (*closure));
++      *closure = (struct tcp_thread_closure)
++        {
++          .obj = obj,
++          .server_index = server_index,
++          .client_socket = client_socket,
++        };
++
++      pthread_t thr
++        = xpthread_create (NULL, server_thread_tcp_client, closure);
++      /* TODO: We should keep track of this thread so that we can
++         block in resolv_test_end until it has exited.  */
++      xpthread_detach (thr);
++    }
++}
++
++/* Create UDP and TCP server sockets.  */
++static void
++make_server_sockets (struct resolv_test_server *server)
++{
++  while (true)
++    {
++      server->socket_udp = xsocket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
++      server->socket_tcp = xsocket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
++
++      /* Pick the address for the UDP socket.  */
++      server->address = (struct sockaddr_in)
++        {
++          .sin_family = AF_INET,
++          .sin_addr = {.s_addr = htonl (INADDR_LOOPBACK)}
++        };
++      xbind (server->socket_udp,
++             (struct sockaddr *)&server->address, sizeof (server->address));
++
++      /* Retrieve the address. */
++      socklen_t addrlen = sizeof (server->address);
++      xgetsockname (server->socket_udp,
++                    (struct sockaddr *)&server->address, &addrlen);
++
++      /* Bind the TCP socket to the same address.  */
++      {
++        int on = 1;
++        xsetsockopt (server->socket_tcp, SOL_SOCKET, SO_REUSEADDR,
++                     &on, sizeof (on));
++      }
++      if (bind (server->socket_tcp,
++                (struct sockaddr *)&server->address,
++                sizeof (server->address)) != 0)
++        {
++          /* Port collision.  The UDP bind succeeded, but the TCP BIND
++             failed.  We assume here that the kernel will pick the
++             next local UDP address randomly.  */
++          if (errno == EADDRINUSE)
++            {
++              xclose (server->socket_udp);
++              xclose (server->socket_tcp);
++              continue;
++            }
++          FAIL_EXIT1 ("TCP bind: %m");
++        }
++      xlisten (server->socket_tcp, 5);
++      break;
++    }
++}
++
++/* One-time initialization of NSS.  */
++static void
++resolv_redirect_once (void)
++{
++  /* Only use nss_dns.  */
++  __nss_configure_lookup ("hosts", "dns");
++  __nss_configure_lookup ("networks", "dns");
++  /* Enter a network namespace for isolation and firewall state
++     cleanup.  The tests will still work if these steps fail, but they
++     may be less reliable.  */
++  support_become_root ();
++  support_enter_network_namespace ();
++}
++pthread_once_t resolv_redirect_once_var = PTHREAD_ONCE_INIT;
++
++void
++resolv_test_init (void)
++{
++  /* Perform one-time initialization of NSS.  */
++  xpthread_once (&resolv_redirect_once_var, resolv_redirect_once);
++}
++
++/* Copy the search path from CONFIG.search to the _res object.  */
++static void
++set_search_path (struct resolv_redirect_config config)
++{
++  memset (_res.defdname, 0, sizeof (_res.defdname));
++  memset (_res.dnsrch, 0, sizeof (_res.dnsrch));
++
++  char *current = _res.defdname;
++  char *end = current + sizeof (_res.defdname);
++
++  for (unsigned int i = 0;
++       i < sizeof (config.search) / sizeof (config.search[0]); ++i)
++    {
++      if (config.search[i] == NULL)
++        continue;
++
++      size_t length = strlen (config.search[i]) + 1;
++      size_t remaining = end - current;
++      TEST_VERIFY_EXIT (length <= remaining);
++      memcpy (current, config.search[i], length);
++      _res.dnsrch[i] = current;
++      current += length;
++    }
++}
++
++struct resolv_test *
++resolv_test_start (struct resolv_redirect_config config)
++{
++  /* Apply configuration defaults.  */
++  if (config.nscount == 0)
++    config.nscount = resolv_max_test_servers;
++
++  struct resolv_test *obj = xmalloc (sizeof (*obj));
++  *obj = (struct resolv_test) {
++    .config = config,
++    .lock = PTHREAD_MUTEX_INITIALIZER,
++  };
++
++  resolv_test_init ();
++
++  /* Create all the servers, to reserve the necessary ports.  */
++  for (int server_index = 0; server_index < config.nscount; ++server_index)
++    make_server_sockets (obj->servers + server_index);
++
++  /* Start server threads.  Disable the server ports, as
++     requested.  */
++  for (int server_index = 0; server_index < config.nscount; ++server_index)
++    {
++      struct resolv_test_server *server = obj->servers + server_index;
++      if (config.servers[server_index].disable_udp)
++        {
++          xclose (server->socket_udp);
++          server->socket_udp = -1;
++        }
++      else if (!config.single_thread_udp)
++        server->thread_udp = start_server_thread (obj, server_index,
++                                                  server_thread_udp);
++      if (config.servers[server_index].disable_tcp)
++        {
++          xclose (server->socket_tcp);
++          server->socket_tcp = -1;
++        }
++      else
++        server->thread_tcp = start_server_thread (obj, server_index,
++                                                  server_thread_tcp);
++    }
++  if (config.single_thread_udp)
++    start_server_thread_udp_single (obj);
++
++  int timeout = 1;
++
++  /* Initialize libresolv.  */
++  TEST_VERIFY_EXIT (res_init () == 0);
++
++  /* Disable IPv6 name server addresses.  The code below only
++     overrides the IPv4 addresses.  */
++  __res_iclose (&_res, true);
++  _res._u._ext.nscount = 0;
++
++  /* Redirect queries to the server socket.  */
++  if (test_verbose)
++    {
++      printf ("info: old timeout value: %d\n", _res.retrans);
++      printf ("info: old retry attempt value: %d\n", _res.retry);
++      printf ("info: old _res.options: 0x%lx\n", _res.options);
++      printf ("info: old _res.nscount value: %d\n", _res.nscount);
++      printf ("info: old _res.ndots value: %d\n", _res.ndots);
++    }
++  _res.retrans = timeout;
++  _res.retry = 4;
++  _res.nscount = config.nscount;
++  _res.options = RES_INIT | RES_RECURSE | RES_DEFNAMES | RES_DNSRCH;
++  _res.ndots = 1;
++  if (test_verbose)
++    {
++      printf ("info: new timeout value: %d\n", _res.retrans);
++      printf ("info: new retry attempt value: %d\n", _res.retry);
++      printf ("info: new _res.options: 0x%lx\n", _res.options);
++      printf ("info: new _res.nscount value: %d\n", _res.nscount);
++      printf ("info: new _res.ndots value: %d\n", _res.ndots);
++    }
++  for (int server_index = 0; server_index < config.nscount; ++server_index)
++    {
++      _res.nsaddr_list[server_index] = obj->servers[server_index].address;
++      if (test_verbose)
++        {
++          char buf[256];
++          TEST_VERIFY_EXIT
++            (inet_ntop (AF_INET, &obj->servers[server_index].address.sin_addr,
++                        buf, sizeof (buf)) != NULL);
++          printf ("info: server %d: %s/%u\n",
++                  server_index, buf,
++                  htons (obj->servers[server_index].address.sin_port));
++        }
++    }
++
++  set_search_path (config);
++
++  return obj;
++}
++
++void
++resolv_test_end (struct resolv_test *obj)
++{
++  res_close ();
++
++  xpthread_mutex_lock (&obj->lock);
++  obj->termination_requested = true;
++  xpthread_mutex_unlock (&obj->lock);
++
++  /* Send trigger packets to unblock the server threads.  */
++  for (int server_index = 0; server_index < obj->config.nscount;
++       ++server_index)
++    {
++      if (!obj->config.servers[server_index].disable_udp)
++        {
++          int sock = xsocket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
++          xsendto (sock, "", 1, 0,
++                   (struct sockaddr *) &obj->servers[server_index].address,
++                   sizeof (obj->servers[server_index].address));
++          xclose (sock);
++        }
++      if (!obj->config.servers[server_index].disable_tcp)
++        {
++          int sock = xsocket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
++          xconnect (sock,
++                    (struct sockaddr *) &obj->servers[server_index].address,
++                    sizeof (obj->servers[server_index].address));
++          xclose (sock);
++        }
++    }
++
++  if (obj->config.single_thread_udp)
++    xpthread_join (obj->thread_udp_single);
++
++  /* Wait for the server threads to terminate.  */
++  for (int server_index = 0; server_index < obj->config.nscount;
++       ++server_index)
++    {
++      if (!obj->config.servers[server_index].disable_udp)
++        {
++          if (!obj->config.single_thread_udp)
++            xpthread_join (obj->servers[server_index].thread_udp);
++          xclose (obj->servers[server_index].socket_udp);
++        }
++      if (!obj->config.servers[server_index].disable_tcp)
++        {
++          xpthread_join (obj->servers[server_index].thread_tcp);
++          xclose (obj->servers[server_index].socket_tcp);
++        }
++    }
++
++  free (obj);
++}
+diff --git a/support/resolv_test.h b/support/resolv_test.h
+new file mode 100644
+index 0000000000..6498751569
+--- /dev/null
++++ b/support/resolv_test.h
+@@ -0,0 +1,180 @@
++/* DNS test framework and libresolv redirection.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_RESOLV_TEST_H
++#define SUPPORT_RESOLV_TEST_H
++
++#include <arpa/nameser.h>
++#include <stdbool.h>
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++/* Information about EDNS properties of a DNS query.  */
++struct resolv_edns_info
++{
++  bool active;
++  uint8_t extended_rcode;
++  uint8_t version;
++  uint16_t flags;
++  uint16_t payload_size;
++};
++
++/* This struct provides context information when the response callback
++   specified in struct resolv_redirect_config is invoked. */
++struct resolv_response_context
++{
++  const unsigned char *query_buffer;
++  size_t query_length;
++  int server_index;
++  bool tcp;
++  struct resolv_edns_info edns;
++};
++
++/* This opaque struct is used to construct responses from within the
++   response callback function.  */
++struct resolv_response_builder;
++
++/* This opaque struct collects information about the resolver testing
++   currently in progress.  */
++struct resolv_test;
++
++enum
++  {
++    /* Maximum number of test servers supported by the framework.  */
++    resolv_max_test_servers = 3,
++  };
++
++/* Configuration settings specific to individual test servers.  */
++struct resolv_redirect_server_config
++{
++  bool disable_tcp;             /* If true, no TCP server is listening.  */
++  bool disable_udp;             /* If true, no UDP server is listening.  */
++};
++
++/* Instructions for setting up the libresolv redirection.  */
++struct resolv_redirect_config
++{
++  /* The response_callback function is called for every incoming DNS
++     packet, over UDP or TCP.  It must be specified, the other
++     configuration settings are optional.  */
++  void (*response_callback) (const struct resolv_response_context *,
++                             struct resolv_response_builder *,
++                             const char *qname,
++                             uint16_t qclass, uint16_t qtype);
++
++  /* Per-server configuration.  */
++  struct resolv_redirect_server_config servers[resolv_max_test_servers];
++
++  /* Search path entries.  The first entry serves as the default
++     domain name as well.  */
++  const char *search[7];
++
++  /* Number of servers to activate in resolv.  0 means the default,
++     resolv_max_test_servers.  */
++  int nscount;
++
++  /* If true, use a single thread to process all UDP queries.  This
++     may results in more predictable ordering of queries and
++     responses.  */
++  bool single_thread_udp;
++};
++
++/* Configure NSS to use, nss_dns only for aplicable databases, and try
++   to put the process into a network namespace for better isolation.
++   This may have to be called before resolv_test_start, before the
++   process creates any threads.  Otherwise, initialization is
++   performed by resolv_test_start implicitly.  */
++void resolv_test_init (void);
++
++/* Initiate resolver testing.  This updates the _res variable as
++   needed.  As a side effect, NSS is reconfigured to use nss_dns only
++   for aplicable databases, and the process may enter a network
++   namespace for better isolation.  */
++struct resolv_test *resolv_test_start (struct resolv_redirect_config);
++
++/* Call this function at the end of resolver testing, to free
++   resources and report pending errors (if any).  */
++void resolv_test_end (struct resolv_test *);
++
++/* The remaining facilities in this file are used for constructing
++   response packets from the response_callback function.  */
++
++/* Special settings for constructing responses from the callback.  */
++struct resolv_response_flags
++{
++  /* 4-bit response code to incorporate into the response. */
++  unsigned char rcode;
++
++  /* If true, the TC (truncation) flag will be set.  */
++  bool tc;
++
++  /* Initial section count values.  Can be used to artificially
++     increase the counts, for malformed packet testing.*/
++  unsigned short qdcount;
++  unsigned short ancount;
++  unsigned short nscount;
++  unsigned short adcount;
++};
++
++/* Begin a new response with the requested flags.  Must be called
++   first.  */
++void resolv_response_init (struct resolv_response_builder *,
++                           struct resolv_response_flags);
++
++/* Switches to the section in the response packet.  Only forward
++   movement is supported.  */
++void resolv_response_section (struct resolv_response_builder *, ns_sect);
++
++/* Add a question record to the question section.  */
++void resolv_response_add_question (struct resolv_response_builder *,
++                                   const char *name, uint16_t class,
++                                   uint16_t type);
++/* Starts a new resource record with the specified owner name, class,
++   type, and TTL.  Data is supplied with resolv_response_add_data or
++   resolv_response_add_name.  */
++void resolv_response_open_record (struct resolv_response_builder *,
++                                  const char *name, uint16_t class,
++                                  uint16_t type, uint32_t ttl);
++
++/* Add unstructed bytes to the RDATA part of a resource record.  */
++void resolv_response_add_data (struct resolv_response_builder *,
++                               const void *, size_t);
++
++/* Add a compressed domain name to the RDATA part of a resource
++   record.  */
++void resolv_response_add_name (struct resolv_response_builder *,
++                               const char *name);
++
++/* Mark the end of the constructed record.  Must be called last.  */
++void resolv_response_close_record (struct resolv_response_builder *);
++
++/* Drop this query packet (that is, do not send a response, not even
++   an empty packet).  */
++void resolv_response_drop (struct resolv_response_builder *);
++
++/* In TCP mode, close the connection after this packet (if a response
++   is sent).  */
++void resolv_response_close (struct resolv_response_builder *);
++
++/* The size of the response packet built so far.  */
++size_t resolv_response_length (const struct resolv_response_builder *);
++
++__END_DECLS
++
++#endif /* SUPPORT_RESOLV_TEST_H */
+diff --git a/support/run_diff.h b/support/run_diff.h
+new file mode 100644
+index 0000000000..f65b5dd22c
+--- /dev/null
++++ b/support/run_diff.h
+@@ -0,0 +1,31 @@
++/* Invoke the system diff tool to compare two strings.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_RUN_DIFF_H
++#define SUPPORT_RUN_DIFF_H
++
++/* Compare the two NUL-terminated strings LEFT and RIGHT using the
++   diff tool.  Label the sides of the diff with LEFT_LABEL and
++   RIGHT_LABEL, respectively.
++
++   This function assumes that LEFT and RIGHT are different
++   strings.  */
++void support_run_diff (const char *left_label, const char *left,
++                       const char *right_label, const char *right);
++
++#endif /* SUPPORT_RUN_DIFF_H */
+diff --git a/support/set_fortify_handler.c b/support/set_fortify_handler.c
+new file mode 100644
+index 0000000000..f434a8082a
+--- /dev/null
++++ b/support/set_fortify_handler.c
+@@ -0,0 +1,34 @@
++/* Set signal handler for use in fortify tests.
++   Copyright (C) 2016-2017 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 <support/support.h>
++
++#include <signal.h>
++
++void
++set_fortify_handler (void (*handler) (int sig))
++{
++  struct sigaction sa;
++
++  sa.sa_handler = handler;
++  sa.sa_flags = 0;
++  sigemptyset (&sa.sa_mask);
++
++  sigaction (SIGABRT, &sa, NULL);
++  ignore_stderr ();
++}
+diff --git a/support/support-xstat.c b/support/support-xstat.c
+new file mode 100644
+index 0000000000..86a81ec601
+--- /dev/null
++++ b/support/support-xstat.c
+@@ -0,0 +1,30 @@
++/* stat64 with error checking.
++   Copyright (C) 2017 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/>.  */
++
++/* NB: Non-standard file name to avoid sysdeps override for xstat.  */
++
++#include <support/check.h>
++#include <support/xunistd.h>
++#include <sys/stat.h>
++
++void
++xstat (const char *path, struct stat64 *result)
++{
++  if (stat64 (path, result) != 0)
++    FAIL_EXIT1 ("stat64 (\"%s\"): %m", path);
++}
+diff --git a/support/support.h b/support/support.h
+new file mode 100644
+index 0000000000..4b5f04c2cc
+--- /dev/null
++++ b/support/support.h
+@@ -0,0 +1,74 @@
++/* Common extra functions.
++   Copyright (C) 2016-2017 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 header file should only contain definitions compatible with
++   C90.  (Using __attribute__ is fine because <features.h> provides a
++   fallback.)  */
++
++#ifndef SUPPORT_H
++#define SUPPORT_H
++
++#include <stddef.h>
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++/* Write a message to standard output.  Can be used in signal
++   handlers.  */
++void write_message (const char *message) __attribute__ ((nonnull (1)));
++
++/* Avoid all the buffer overflow messages on stderr.  */
++void ignore_stderr (void);
++
++/* Set fortification error handler.  Used when tests want to verify that bad
++   code is caught by the library.  */
++void set_fortify_handler (void (*handler) (int sig));
++
++/* Report an out-of-memory error for the allocation of SIZE bytes in
++   FUNCTION, terminating the process.  */
++void oom_error (const char *function, size_t size)
++  __attribute__ ((nonnull (1)));
++
++/* Return a pointer to a memory region of SIZE bytes.  The memory is
++   initialized to zero and will be shared with subprocesses (across
++   fork).  The returned pointer must be freed using
++   support_shared_free; it is not compatible with the malloc
++   functions.  */
++void *support_shared_allocate (size_t size);
++
++/* Deallocate a pointer returned by support_shared_allocate.  */
++void support_shared_free (void *);
++
++/* Write CONTENTS to the file PATH.  Create or truncate the file as
++   needed.  The file mode is 0666 masked by the umask.  Terminate the
++   process on error.  */
++void support_write_file_string (const char *path, const char *contents);
++
++/* Error-checking wrapper functions which terminate the process on
++   error.  */
++
++void *xmalloc (size_t) __attribute__ ((malloc));
++void *xcalloc (size_t n, size_t s) __attribute__ ((malloc));
++void *xrealloc (void *p, size_t n);
++char *xasprintf (const char *format, ...)
++  __attribute__ ((format (printf, 1, 2), malloc));
++char *xstrdup (const char *);
++
++__END_DECLS
++
++#endif /* SUPPORT_H */
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/s_fdim.S b/support/support_become_root.c
+similarity index 57%
+rename from sysdeps/sparc/sparc32/sparcv9/fpu/s_fdim.S
+rename to support/support_become_root.c
+index 37f7f44dfa..3fa0bd4ac0 100644
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/s_fdim.S
++++ b/support/support_become_root.c
+@@ -1,7 +1,6 @@
+-/* Compute positive difference, sparc 32-bit+v9.
+-   Copyright (C) 2013-2016 Free Software Foundation, Inc.
++/* Acquire root privileges.
++   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by David S. Miller <davem@davemloft.net>.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -17,24 +16,25 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-#include <sysdep.h>
+-#include <math_ldbl_opt.h>
++#include <support/namespace.h>
+ 
+-ENTRY(__fdim)
+-	std	%o0, [%sp + 72]
+-	std	%o2, [%sp + 80]
+-	ldd	[%sp + 72], %f0
+-	ldd	[%sp + 80], %f2
+-	fcmpd	%f0, %f2
+-	fbug	1f
+-	 nop
+-	fzero	%f0
+-	fnegd	%f0, %f2
+-1:	retl
+-	 fsubd	%f0, %f2, %f0
+-END(__fdim)
+-weak_alias (__fdim, fdim)
++#include <sched.h>
++#include <stdio.h>
++#include <unistd.h>
+ 
+-#if LONG_DOUBLE_COMPAT(libm, GLIBC_2_1)
+-compat_symbol (libm, __fdim, fdiml, GLIBC_2_1);
++bool
++support_become_root (void)
++{
++#ifdef CLONE_NEWUSER
++  if (unshare (CLONE_NEWUSER | CLONE_NEWNS) == 0)
++    /* Even if we do not have UID zero, we have extended privileges at
++       this point.  */
++    return true;
+ #endif
++  if (setuid (0) != 0)
++    {
++      printf ("warning: could not become root outside namespace (%m)\n");
++      return false;
++    }
++  return true;
++}
+diff --git a/support/support_can_chroot.c b/support/support_can_chroot.c
+new file mode 100644
+index 0000000000..0dfd2deb54
+--- /dev/null
++++ b/support/support_can_chroot.c
+@@ -0,0 +1,65 @@
++/* Return true if the process can perform a chroot operation.
++   Copyright (C) 2017 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 <errno.h>
++#include <stdio.h>
++#include <support/check.h>
++#include <support/namespace.h>
++#include <support/support.h>
++#include <sys/stat.h>
++#include <unistd.h>
++#include <xunistd.h>
++
++static void
++callback (void *closure)
++{
++  int *result = closure;
++  struct stat64 before;
++  xstat ("/dev", &before);
++  if (chroot ("/dev") != 0)
++    {
++      *result = errno;
++      return;
++    }
++  struct stat64 after;
++  xstat ("/", &after);
++  TEST_VERIFY (before.st_dev == after.st_dev);
++  TEST_VERIFY (before.st_ino == after.st_ino);
++  *result = 0;
++}
++
++bool
++support_can_chroot (void)
++{
++  int *result = support_shared_allocate (sizeof (*result));
++  *result = 0;
++  support_isolate_in_subprocess (callback, result);
++  bool ok = *result == 0;
++  if (!ok)
++    {
++      static bool already_warned;
++      if (!already_warned)
++        {
++          already_warned = true;
++          errno = *result;
++          printf ("warning: this process does not support chroot: %m\n");
++        }
++    }
++  support_shared_free (result);
++  return ok;
++}
+diff --git a/support/support_capture_subprocess.c b/support/support_capture_subprocess.c
+new file mode 100644
+index 0000000000..030f124252
+--- /dev/null
++++ b/support/support_capture_subprocess.c
+@@ -0,0 +1,108 @@
++/* Capture output from a subprocess.
++   Copyright (C) 2017 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 <support/capture_subprocess.h>
++
++#include <errno.h>
++#include <stdlib.h>
++#include <support/check.h>
++#include <support/xunistd.h>
++#include <support/xsocket.h>
++
++static void
++transfer (const char *what, struct pollfd *pfd, struct xmemstream *stream)
++{
++  if (pfd->revents != 0)
++    {
++      char buf[1024];
++      ssize_t ret = TEMP_FAILURE_RETRY (read (pfd->fd, buf, sizeof (buf)));
++      if (ret < 0)
++        {
++          support_record_failure ();
++          printf ("error: reading from subprocess %s: %m", what);
++          pfd->events = 0;
++          pfd->revents = 0;
++        }
++      else if (ret == 0)
++        {
++          /* EOF reached.  Stop listening.  */
++          pfd->events = 0;
++          pfd->revents = 0;
++        }
++      else
++        /* Store the data just read.   */
++        TEST_VERIFY (fwrite (buf, ret, 1, stream->out) == 1);
++    }
++}
++
++struct support_capture_subprocess
++support_capture_subprocess (void (*callback) (void *), void *closure)
++{
++  struct support_capture_subprocess result;
++  xopen_memstream (&result.out);
++  xopen_memstream (&result.err);
++
++  int stdout_pipe[2];
++  xpipe (stdout_pipe);
++  int stderr_pipe[2];
++  xpipe (stderr_pipe);
++
++  TEST_VERIFY (fflush (stdout) == 0);
++  TEST_VERIFY (fflush (stderr) == 0);
++
++  pid_t pid = xfork ();
++  if (pid == 0)
++    {
++      xclose (stdout_pipe[0]);
++      xclose (stderr_pipe[0]);
++      xdup2 (stdout_pipe[1], STDOUT_FILENO);
++      xdup2 (stderr_pipe[1], STDERR_FILENO);
++      callback (closure);
++      _exit (0);
++    }
++  xclose (stdout_pipe[1]);
++  xclose (stderr_pipe[1]);
++
++  struct pollfd fds[2] =
++    {
++      { .fd = stdout_pipe[0], .events = POLLIN },
++      { .fd = stderr_pipe[0], .events = POLLIN },
++    };
++
++  do
++    {
++      xpoll (fds, 2, -1);
++      transfer ("stdout", &fds[0], &result.out);
++      transfer ("stderr", &fds[1], &result.err);
++    }
++  while (fds[0].events != 0 || fds[1].events != 0);
++  xclose (stdout_pipe[0]);
++  xclose (stderr_pipe[0]);
++
++  xfclose_memstream (&result.out);
++  xfclose_memstream (&result.err);
++  xwaitpid (pid, &result.status, 0);
++  return result;
++}
++
++void
++support_capture_subprocess_free (struct support_capture_subprocess *p)
++{
++  free (p->out.buffer);
++  free (p->err.buffer);
++}
+diff --git a/support/support_capture_subprocess_check.c b/support/support_capture_subprocess_check.c
+new file mode 100644
+index 0000000000..708c89f331
+--- /dev/null
++++ b/support/support_capture_subprocess_check.c
+@@ -0,0 +1,67 @@
++/* Verify capture output from a subprocess.
++   Copyright (C) 2017 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 <stdbool.h>
++#include <stdio.h>
++#include <support/capture_subprocess.h>
++#include <support/check.h>
++
++static void
++print_context (const char *context, bool *failed)
++{
++  if (*failed)
++    /* Do not duplicate message.  */
++    return;
++  support_record_failure ();
++  printf ("error: subprocess failed: %s\n", context);
++}
++
++void
++support_capture_subprocess_check (struct support_capture_subprocess *proc,
++                                  const char *context, int status,
++                                  int allowed)
++{
++  TEST_VERIFY ((allowed & sc_allow_none)
++               || (allowed & sc_allow_stdout)
++               || (allowed & sc_allow_stderr));
++  TEST_VERIFY (!((allowed & sc_allow_none)
++                 && ((allowed & sc_allow_stdout)
++                     || (allowed & sc_allow_stderr))));
++
++  bool failed = false;
++  if (proc->status != status)
++    {
++      print_context (context, &failed);
++      printf ("error:   expected exit status: %d\n", status);
++      printf ("error:   actual exit status:   %d\n", status);
++    }
++  if (!(allowed & sc_allow_stdout) && proc->out.length != 0)
++    {
++      print_context (context, &failed);
++      printf ("error:   unexpected output from subprocess\n");
++      fwrite (proc->out.buffer, proc->out.length, 1, stdout);
++      puts ("\n");
++    }
++  if (!(allowed & sc_allow_stderr) && proc->err.length != 0)
++    {
++      print_context (context, &failed);
++      printf ("error:   unexpected error output from subprocess\n");
++      fwrite (proc->err.buffer, proc->err.length, 1, stdout);
++      puts ("\n");
++    }
++}
+diff --git a/support/support_enter_network_namespace.c b/support/support_enter_network_namespace.c
+new file mode 100644
+index 0000000000..28b0ee29cf
+--- /dev/null
++++ b/support/support_enter_network_namespace.c
+@@ -0,0 +1,75 @@
++/* Enter a network namespace.
++   Copyright (C) 2016-2017 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 <support/namespace.h>
++
++#include <net/if.h>
++#include <sched.h>
++#include <stdio.h>
++#include <string.h>
++#include <support/check.h>
++#include <support/xsocket.h>
++#include <support/xunistd.h>
++#include <sys/ioctl.h>
++#include <unistd.h>
++
++static bool in_uts_namespace;
++
++bool
++support_enter_network_namespace (void)
++{
++#ifdef CLONE_NEWUTS
++  if (unshare (CLONE_NEWUTS) == 0)
++    in_uts_namespace = true;
++  else
++    printf ("warning: unshare (CLONE_NEWUTS) failed: %m\n");
++#endif
++
++#ifdef CLONE_NEWNET
++  if (unshare (CLONE_NEWNET) == 0)
++    {
++      /* Bring up the loopback interface.  */
++      int fd = xsocket (AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0);
++      struct ifreq req;
++      strcpy (req.ifr_name, "lo");
++      TEST_VERIFY_EXIT (ioctl (fd, SIOCGIFFLAGS, &req) == 0);
++      bool already_up = req.ifr_flags & IFF_UP;
++      if (already_up)
++        /* This means that we likely have not achieved isolation from
++           the parent namespace.  */
++        printf ("warning: loopback interface already exists"
++                " in new network namespace\n");
++      else
++        {
++          req.ifr_flags |= IFF_UP | IFF_RUNNING;
++          TEST_VERIFY_EXIT (ioctl (fd, SIOCSIFFLAGS, &req) == 0);
++        }
++      xclose (fd);
++
++      return !already_up;
++    }
++#endif
++  printf ("warning: could not enter network namespace\n");
++  return false;
++}
++
++bool
++support_in_uts_namespace (void)
++{
++  return in_uts_namespace;
++}
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/s_fdimf.S b/support/support_format_address_family.c
+similarity index 63%
+rename from sysdeps/sparc/sparc32/sparcv9/fpu/s_fdimf.S
+rename to support/support_format_address_family.c
+index 9e0e3f21be..5d42c42a45 100644
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/s_fdimf.S
++++ b/support/support_format_address_family.c
+@@ -1,7 +1,6 @@
+-/* Compute positive difference, sparc 32-bit+v9.
+-   Copyright (C) 2013-2016 Free Software Foundation, Inc.
++/* Convert an address family to a string.
++   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by David S. Miller <davem@davemloft.net>.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -17,19 +16,20 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-#include <sysdep.h>
++#include <support/format_nss.h>
+ 
+-ENTRY(__fdimf)
+-	st	%o0, [%sp + 72]
+-	st	%o1, [%sp + 76]
+-	ld	[%sp + 72], %f0
+-	ld	[%sp + 76], %f1
+-	fcmps	%f0, %f1
+-	fbug	1f
+-	 nop
+-	fzeros	%f0
+-	fnegs	%f0, %f1
+-1:	retl
+-	 fsubs	%f0, %f1, %f0
+-END(__fdimf)
+-weak_alias (__fdimf, fdimf)
++#include <support/support.h>
++
++char *
++support_format_address_family (int family)
++{
++  switch (family)
++    {
++    case AF_INET:
++      return xstrdup ("INET");
++    case AF_INET6:
++      return xstrdup ("INET6");
++    default:
++      return xasprintf ("<unknown address family %d>", family);
++    }
++}
+diff --git a/support/support_format_addrinfo.c b/support/support_format_addrinfo.c
+new file mode 100644
+index 0000000000..eedb030591
+--- /dev/null
++++ b/support/support_format_addrinfo.c
+@@ -0,0 +1,239 @@
++/* Convert struct addrinfo values to a string.
++   Copyright (C) 2016-2017 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 <support/format_nss.h>
++
++#include <arpa/inet.h>
++#include <errno.h>
++#include <stdio.h>
++#include <support/support.h>
++#include <support/xmemstream.h>
++
++static size_t
++socket_address_length (int family)
++{
++  switch (family)
++    {
++    case AF_INET:
++      return sizeof (struct sockaddr_in);
++    case AF_INET6:
++      return sizeof (struct sockaddr_in6);
++    default:
++      return -1;
++    }
++}
++
++static void
++format_ai_flags_1 (FILE *out, struct addrinfo *ai, int flag, const char *name,
++                   int * flags_printed)
++{
++  if ((ai->ai_flags & flag) != 0)
++    fprintf (out, " %s", name);
++  *flags_printed |= flag;
++}
++
++static void
++format_ai_flags (FILE *out, struct addrinfo *ai)
++{
++  if (ai == NULL)
++    return;
++
++  if (ai->ai_flags != 0)
++    {
++      fprintf (out, "flags:");
++      int flags_printed = 0;
++#define FLAG(flag) format_ai_flags_1 (out, ai, flag, #flag, &flags_printed)
++      FLAG (AI_PASSIVE);
++      FLAG (AI_CANONNAME);
++      FLAG (AI_NUMERICHOST);
++      FLAG (AI_V4MAPPED);
++      FLAG (AI_ALL);
++      FLAG (AI_ADDRCONFIG);
++      FLAG (AI_IDN);
++      FLAG (AI_CANONIDN);
++      FLAG (AI_IDN_ALLOW_UNASSIGNED);
++      FLAG (AI_IDN_USE_STD3_ASCII_RULES);
++      FLAG (AI_NUMERICSERV);
++#undef FLAG
++      int remaining = ai->ai_flags & ~flags_printed;
++      if (remaining != 0)
++        fprintf (out, " %08x", remaining);
++      fprintf (out, "\n");
++    }
++
++  /* Report flag mismatches within the list.  */
++  int flags = ai->ai_flags;
++  int index = 1;
++  ai = ai->ai_next;
++  while (ai != NULL)
++    {
++      if (ai->ai_flags != flags)
++        fprintf (out, "error: flags at %d: 0x%x expected, 0x%x actual\n",
++                 index, flags, ai->ai_flags);
++      ai = ai->ai_next;
++      ++index;
++    }
++}
++
++static void
++format_ai_canonname (FILE *out, struct addrinfo *ai)
++{
++  if (ai == NULL)
++    return;
++  if (ai->ai_canonname != NULL)
++    fprintf (out, "canonname: %s\n", ai->ai_canonname);
++
++  /* Report incorrectly set ai_canonname fields on subsequent list
++     entries.  */
++  int index = 1;
++  ai = ai->ai_next;
++  while (ai != NULL)
++    {
++      if (ai->ai_canonname != NULL)
++        fprintf (out, "error: canonname set at %d: %s\n",
++                 index, ai->ai_canonname);
++      ai = ai->ai_next;
++      ++index;
++    }
++}
++
++static void
++format_ai_one (FILE *out, struct addrinfo *ai)
++{
++  {
++    char type_buf[32];
++    const char *type_str;
++    char proto_buf[32];
++    const char *proto_str;
++
++    /* ai_socktype */
++    switch (ai->ai_socktype)
++      {
++      case SOCK_RAW:
++        type_str = "RAW";
++        break;
++      case SOCK_DGRAM:
++        type_str = "DGRAM";
++        break;
++      case SOCK_STREAM:
++        type_str = "STREAM";
++        break;
++      default:
++        snprintf (type_buf, sizeof (type_buf), "%d", ai->ai_socktype);
++        type_str = type_buf;
++      }
++
++    /* ai_protocol */
++    switch (ai->ai_protocol)
++      {
++      case IPPROTO_IP:
++        proto_str = "IP";
++        break;
++      case IPPROTO_UDP:
++        proto_str = "UDP";
++        break;
++      case IPPROTO_TCP:
++        proto_str = "TCP";
++        break;
++      default:
++        snprintf (proto_buf, sizeof (proto_buf), "%d", ai->ai_protocol);
++        proto_str = proto_buf;
++      }
++    fprintf (out, "address: %s/%s", type_str, proto_str);
++  }
++
++  /* ai_addrlen */
++  if (ai->ai_addrlen != socket_address_length (ai->ai_family))
++    {
++      char *family = support_format_address_family (ai->ai_family);
++      fprintf (out, "error: invalid address length %d for %s\n",
++               ai->ai_addrlen, family);
++      free (family);
++    }
++
++  /* ai_addr */
++  {
++    char buf[128];
++    uint16_t port;
++    const char *ret;
++    switch (ai->ai_family)
++      {
++      case AF_INET:
++        {
++          struct sockaddr_in *sin = (struct sockaddr_in *) ai->ai_addr;
++          ret = inet_ntop (AF_INET, &sin->sin_addr, buf, sizeof (buf));
++          port = sin->sin_port;
++        }
++        break;
++      case AF_INET6:
++        {
++          struct sockaddr_in6 *sin = (struct sockaddr_in6 *) ai->ai_addr;
++          ret = inet_ntop (AF_INET6, &sin->sin6_addr, buf, sizeof (buf));
++          port = sin->sin6_port;
++        }
++        break;
++      default:
++        errno = EAFNOSUPPORT;
++        ret = NULL;
++      }
++    if (ret == NULL)
++        fprintf (out, "error: inet_top failed: %m\n");
++    else
++      fprintf (out, " %s %u\n", buf, ntohs (port));
++  }
++}
++
++/* Format all the addresses in one address family.  */
++static void
++format_ai_family (FILE *out, struct addrinfo *ai, int family)
++{
++  while (ai)
++    {
++      if (ai->ai_family == family)
++        format_ai_one (out, ai);
++      ai = ai->ai_next;
++    }
++}
++
++char *
++support_format_addrinfo (struct addrinfo *ai, int ret)
++{
++  int errno_copy = errno;
++
++  struct xmemstream mem;
++  xopen_memstream (&mem);
++  if (ret != 0)
++    {
++      fprintf (mem.out, "error: %s\n", gai_strerror (ret));
++      if (ret == EAI_SYSTEM)
++        {
++          errno = errno_copy;
++          fprintf (mem.out, "error: %m\n");
++        }
++    }
++  else
++    {
++      format_ai_flags (mem.out, ai);
++      format_ai_canonname (mem.out, ai);
++      format_ai_family (mem.out, ai, AF_INET);
++      format_ai_family (mem.out, ai, AF_INET6);
++    }
++
++  xfclose_memstream (&mem);
++  return mem.buffer;
++}
+diff --git a/support/support_format_dns_packet.c b/support/support_format_dns_packet.c
+new file mode 100644
+index 0000000000..2992c57971
+--- /dev/null
++++ b/support/support_format_dns_packet.c
+@@ -0,0 +1,222 @@
++/* Convert a DNS packet to a human-readable representation.
++   Copyright (C) 2016-2017 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 <support/format_nss.h>
++
++#include <arpa/inet.h>
++#include <resolv.h>
++#include <support/check.h>
++#include <support/support.h>
++#include <support/xmemstream.h>
++
++struct in_buffer
++{
++  const unsigned char *data;
++  size_t size;
++};
++
++static inline bool
++extract_8 (struct in_buffer *in, unsigned char *value)
++{
++  if (in->size == 0)
++    return false;
++  *value = in->data[0];
++  ++in->data;
++  --in->size;
++  return true;
++}
++
++static inline bool
++extract_16 (struct in_buffer *in, unsigned short *value)
++{
++  if (in->size < 2)
++    return false;
++  *value = (in->data[0] << 8) | in->data[1];
++  in->data += 2;
++  in->size -= 2;
++  return true;
++}
++
++static inline bool
++extract_32 (struct in_buffer *in, unsigned *value)
++{
++  if (in->size < 4)
++    return false;
++  unsigned a = in->data[0];
++  unsigned b = in->data[1];
++  unsigned c = in->data[2];
++  unsigned d = in->data[3];
++  *value = (a << 24) | (b << 16) | (c << 8) | d;
++  in->data += 4;
++  in->size -= 4;
++  return true;
++}
++
++static inline bool
++extract_bytes (struct in_buffer *in, size_t length, struct in_buffer *value)
++{
++  if (in->size < length)
++    return false;
++  *value = (struct in_buffer) {in->data, length};
++  in->data += length;
++  in->size -= length;
++  return true;
++}
++
++struct dname
++{
++  char name[MAXDNAME + 1];
++};
++
++static bool
++extract_name (struct in_buffer full, struct in_buffer *in, struct dname *value)
++{
++  const unsigned char *full_end = full.data + full.size;
++  /* Sanity checks; these indicate buffer misuse.  */
++  TEST_VERIFY_EXIT
++    (!(in->data < full.data || in->data > full_end
++       || in->size > (size_t) (full_end - in->data)));
++  int ret = dn_expand (full.data, full_end, in->data,
++                       value->name, sizeof (value->name));
++  if (ret < 0)
++    return false;
++  in->data += ret;
++  in->size -= ret;
++  return true;
++}
++
++char *
++support_format_dns_packet (const unsigned char *buffer, size_t length)
++{
++  struct in_buffer full = { buffer, length };
++  struct in_buffer in = full;
++  struct xmemstream mem;
++  xopen_memstream (&mem);
++
++  unsigned short txnid;
++  unsigned short flags;
++  unsigned short qdcount;
++  unsigned short ancount;
++  unsigned short nscount;
++  unsigned short adcount;
++  if (!(extract_16 (&in, &txnid)
++        && extract_16 (&in, &flags)
++        && extract_16 (&in, &qdcount)
++        && extract_16 (&in, &ancount)
++        && extract_16 (&in, &nscount)
++        && extract_16 (&in, &adcount)))
++    {
++      fprintf (mem.out, "error: could not parse DNS header\n");
++      goto out;
++    }
++  if (qdcount != 1)
++    {
++      fprintf (mem.out, "error: question count is %d, not 1\n", qdcount);
++      goto out;
++    }
++  struct dname qname;
++  if (!extract_name (full, &in, &qname))
++    {
++      fprintf (mem.out, "error: malformed QNAME\n");
++      goto out;
++    }
++  unsigned short qtype;
++  unsigned short qclass;
++  if (!(extract_16 (&in, &qtype)
++        && extract_16 (&in, &qclass)))
++    {
++      fprintf (mem.out, "error: malformed question\n");
++      goto out;
++    }
++  if (qtype != T_A && qtype != T_AAAA && qtype != T_PTR)
++    {
++      fprintf (mem.out, "error: unsupported QTYPE %d\n", qtype);
++      goto out;
++    }
++
++  fprintf (mem.out, "name: %s\n", qname.name);
++
++  for (int i = 0; i < ancount; ++i)
++    {
++      struct dname rname;
++      if (!extract_name (full, &in, &rname))
++        {
++          fprintf (mem.out, "error: malformed record name\n");
++          goto out;
++        }
++      unsigned short rtype;
++      unsigned short rclass;
++      unsigned ttl;
++      unsigned short rdlen;
++      struct in_buffer rdata;
++      if (!(extract_16 (&in, &rtype)
++            && extract_16 (&in, &rclass)
++            && extract_32 (&in, &ttl)
++            && extract_16 (&in, &rdlen)
++            && extract_bytes (&in, rdlen, &rdata)))
++        {
++          fprintf (mem.out, "error: malformed record header\n");
++          goto out;
++        }
++      /* Skip non-matching record types.  */
++      if ((rtype != qtype && rtype != T_CNAME) || rclass != qclass)
++        continue;
++      switch (rtype)
++        {
++        case T_A:
++          if (rdlen == 4)
++              fprintf (mem.out, "address: %d.%d.%d.%d\n",
++                       rdata.data[0],
++                       rdata.data[1],
++                       rdata.data[2],
++                       rdata.data[3]);
++          else
++            fprintf (mem.out, "error: A record of size %d: %s\n",
++                     rdlen, rname.name);
++          break;
++        case T_AAAA:
++          {
++            if (rdlen == 16)
++              {
++                char buf[100];
++                if (inet_ntop (AF_INET6, rdata.data, buf, sizeof (buf)) == NULL)
++                  fprintf (mem.out, "error: AAAA record decoding failed: %m\n");
++                else
++                  fprintf (mem.out, "address: %s\n", buf);
++              }
++            else
++              fprintf (mem.out, "error: AAAA record of size %d: %s\n",
++                       rdlen, rname.name);
++          }
++          break;
++        case T_CNAME:
++        case T_PTR:
++          {
++            struct dname name;
++            if (extract_name (full, &rdata, &name))
++              fprintf (mem.out, "name: %s\n", name.name);
++            else
++              fprintf (mem.out, "error: malformed CNAME/PTR record\n");
++          }
++        }
++    }
++
++ out:
++  xfclose_memstream (&mem);
++  return mem.buffer;
++}
+diff --git a/support/support_format_herrno.c b/support/support_format_herrno.c
+new file mode 100644
+index 0000000000..493d6ae962
+--- /dev/null
++++ b/support/support_format_herrno.c
+@@ -0,0 +1,45 @@
++/* Convert a h_errno error code to a string.
++   Copyright (C) 2016-2017 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 <support/format_nss.h>
++
++#include <support/support.h>
++
++char *
++support_format_herrno (int code)
++{
++  const char *errstr;
++  switch (code)
++    {
++    case HOST_NOT_FOUND:
++      errstr = "HOST_NOT_FOUND";
++      break;
++    case NO_ADDRESS:
++      errstr = "NO_ADDRESS";
++      break;
++    case NO_RECOVERY:
++      errstr = "NO_RECOVERY";
++      break;
++    case TRY_AGAIN:
++      errstr = "TRY_AGAIN";
++      break;
++    default:
++      return xasprintf ("<invalid h_errno value %d>\n", code);
++    }
++  return xstrdup (errstr);
++}
+diff --git a/support/support_format_hostent.c b/support/support_format_hostent.c
+new file mode 100644
+index 0000000000..5b5f26082e
+--- /dev/null
++++ b/support/support_format_hostent.c
+@@ -0,0 +1,75 @@
++/* Convert a struct hostent object to a string.
++   Copyright (C) 2016-2017 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 <support/format_nss.h>
++
++#include <arpa/inet.h>
++#include <stdio.h>
++#include <support/support.h>
++#include <support/xmemstream.h>
++
++static int
++address_length (int family)
++{
++  switch (family)
++    {
++    case AF_INET:
++      return 4;
++    case AF_INET6:
++      return 16;
++    }
++  return -1;
++}
++
++char *
++support_format_hostent (struct hostent *h)
++{
++  if (h == NULL)
++    {
++      char *value = support_format_herrno (h_errno);
++      char *result = xasprintf ("error: %s\n", value);
++      free (value);
++      return result;
++    }
++
++  struct xmemstream mem;
++  xopen_memstream (&mem);
++
++  fprintf (mem.out, "name: %s\n", h->h_name);
++  for (char **alias = h->h_aliases; *alias != NULL; ++alias)
++    fprintf (mem.out, "alias: %s\n", *alias);
++  for (unsigned i = 0; h->h_addr_list[i] != NULL; ++i)
++    {
++      char buf[128];
++      if (inet_ntop (h->h_addrtype, h->h_addr_list[i],
++                     buf, sizeof (buf)) == NULL)
++        fprintf (mem.out, "error: inet_ntop failed: %m\n");
++      else
++        fprintf (mem.out, "address: %s\n", buf);
++    }
++  if (h->h_length != address_length (h->h_addrtype))
++    {
++      char *family = support_format_address_family (h->h_addrtype);
++      fprintf (mem.out, "error: invalid address length %d for %s\n",
++               h->h_length, family);
++      free (family);
++    }
++
++  xfclose_memstream (&mem);
++  return mem.buffer;
++}
+diff --git a/support/support_format_netent.c b/support/support_format_netent.c
+new file mode 100644
+index 0000000000..020f5720d9
+--- /dev/null
++++ b/support/support_format_netent.c
+@@ -0,0 +1,52 @@
++/* Convert a struct netent object to a string.
++   Copyright (C) 2016-2017 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 <support/format_nss.h>
++
++#include <arpa/inet.h>
++#include <stdio.h>
++#include <support/support.h>
++#include <support/xmemstream.h>
++
++char *
++support_format_netent (struct netent *e)
++{
++  if (e == NULL)
++    {
++      char *value = support_format_herrno (h_errno);
++      char *result = xasprintf ("error: %s\n", value);
++      free (value);
++      return result;
++    }
++
++  struct xmemstream mem;
++  xopen_memstream (&mem);
++
++  if (e->n_name != NULL)
++    fprintf (mem.out, "name: %s\n", e->n_name);
++  for (char **ap = e->n_aliases; *ap != NULL; ++ap)
++    fprintf (mem.out, "alias: %s\n", *ap);
++  if (e->n_addrtype != AF_INET)
++    fprintf (mem.out, "addrtype: %d\n", e->n_addrtype);
++  /* On alpha, e->n_net is an unsigned long.  */
++  unsigned int n_net = e->n_net;
++  fprintf (mem.out, "net: 0x%08x\n", n_net);
++
++  xfclose_memstream (&mem);
++  return mem.buffer;
++}
+diff --git a/support/support_isolate_in_subprocess.c b/support/support_isolate_in_subprocess.c
+new file mode 100644
+index 0000000000..cf48614383
+--- /dev/null
++++ b/support/support_isolate_in_subprocess.c
+@@ -0,0 +1,38 @@
++/* Run a function in a subprocess.
++   Copyright (C) 2017 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 <support/check.h>
++#include <support/xunistd.h>
++
++void
++support_isolate_in_subprocess (void (*callback) (void *), void *closure)
++{
++  pid_t pid = xfork ();
++  if (pid == 0)
++    {
++      /* Child process.  */
++      callback (closure);
++      _exit (0);
++    }
++
++  /* Parent process.  */
++  int status;
++  xwaitpid (pid, &status, 0);
++  if (status != 0)
++    FAIL_EXIT1 ("child process exited with status %d", status);
++}
+diff --git a/support/support_record_failure.c b/support/support_record_failure.c
+new file mode 100644
+index 0000000000..684055c746
+--- /dev/null
++++ b/support/support_record_failure.c
+@@ -0,0 +1,106 @@
++/* Global test failure counter.
++   Copyright (C) 2016-2017 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 <support/check.h>
++#include <support/support.h>
++#include <support/test-driver.h>
++
++#include <stdbool.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <sys/mman.h>
++#include <unistd.h>
++
++/* This structure keeps track of test failures.  The counter is
++   incremented on each failure.  The failed member is set to true if a
++   failure is detected, so that even if the counter wraps around to
++   zero, the failure of a test can be detected.
++
++   The init constructor function below puts *state on a shared
++   annonymous mapping, so that failure reports from subprocesses
++   propagate to the parent process.  */
++struct test_failures
++{
++  unsigned int counter;
++  unsigned int failed;
++};
++static struct test_failures *state;
++
++static __attribute__ ((constructor)) void
++init (void)
++{
++  void *ptr = mmap (NULL, sizeof (*state), PROT_READ | PROT_WRITE,
++                    MAP_ANONYMOUS | MAP_SHARED, -1, 0);
++  if (ptr == MAP_FAILED)
++    {
++      printf ("error: could not map %zu bytes: %m\n", sizeof (*state));
++      exit (1);
++    }
++  /* Zero-initialization of the struct is sufficient.  */
++  state = ptr;
++}
++
++void
++support_record_failure (void)
++{
++  if (state == NULL)
++    {
++      write_message
++        ("error: support_record_failure called without initialization\n");
++      _exit (1);
++    }
++  /* Relaxed MO is sufficient because we are only interested in the
++     values themselves, in isolation.  */
++  __atomic_store_n (&state->failed, 1, __ATOMIC_RELEASE);
++  __atomic_add_fetch (&state->counter, 1, __ATOMIC_RELEASE);
++}
++
++int
++support_report_failure (int status)
++{
++  if (state == NULL)
++    {
++      write_message
++        ("error: support_report_failure called without initialization\n");
++      return 1;
++    }
++
++  /* Relaxed MO is sufficient because acquire test result reporting
++     assumes that exiting from the main thread happens before the
++     error reporting via support_record_failure, which requires some
++     form of external synchronization.  */
++  bool failed = __atomic_load_n (&state->failed, __ATOMIC_RELAXED);
++  if (failed)
++    printf ("error: %u test failures\n",
++            __atomic_load_n (&state->counter, __ATOMIC_RELAXED));
++
++  if ((status == 0 || status == EXIT_UNSUPPORTED) && failed)
++    /* If we have a recorded failure, it overrides a non-failure
++       report from the test function.  */
++    status = 1;
++  return status;
++}
++
++void
++support_record_failure_reset (void)
++{
++  /* Only used for testing the test framework, with external
++     synchronization, but use release MO for consistency.  */
++  __atomic_store_n (&state->failed, 0, __ATOMIC_RELAXED);
++  __atomic_add_fetch (&state->counter, 0, __ATOMIC_RELAXED);
++}
+diff --git a/support/support_run_diff.c b/support/support_run_diff.c
+new file mode 100644
+index 0000000000..f5155de727
+--- /dev/null
++++ b/support/support_run_diff.c
+@@ -0,0 +1,76 @@
++/* Invoke the system diff tool to compare two strings.
++   Copyright (C) 2016-2017 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 <support/run_diff.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include <support/check.h>
++#include <support/support.h>
++#include <support/temp_file.h>
++#include <support/xunistd.h>
++#include <sys/wait.h>
++
++static char *
++write_to_temp_file (const char *prefix, const char *str)
++{
++  char *template = xasprintf ("run_diff-%s", prefix);
++  char *name = NULL;
++  int fd = create_temp_file (template, &name);
++  TEST_VERIFY_EXIT (fd >= 0);
++  free (template);
++  xwrite (fd, str, strlen (str));
++  xclose (fd);
++  return name;
++}
++
++void
++support_run_diff (const char *left_label, const char *left,
++                  const char *right_label, const char *right)
++{
++  /* Ensure that the diff command output is ordered properly with
++     standard output.  */
++  TEST_VERIFY_EXIT (fflush (stdout) == 0);
++
++  char *left_path = write_to_temp_file ("left-diff", left);
++  char *right_path = write_to_temp_file ("right-diff", right);
++
++  pid_t pid = xfork ();
++  if (pid == 0)
++    {
++      execlp ("diff", "diff", "-u",
++              "--label", left_label, "--label", right_label,
++              "--", left_path, right_path,
++              NULL);
++      _exit (17);
++    }
++  else
++    {
++      int status;
++      xwaitpid (pid, &status, 0);
++      if (!WIFEXITED (status) || WEXITSTATUS (status) != 1)
++        printf ("warning: could not run diff, exit status: %d\n"
++                "*** %s ***\n%s\n"
++                "*** %s ***\n%s\n",
++                status, left_label, left, right_label, right);
++    }
++
++  free (right_path);
++  free (left_path);
++}
+diff --git a/support/support_shared_allocate.c b/support/support_shared_allocate.c
+new file mode 100644
+index 0000000000..61d088e8cf
+--- /dev/null
++++ b/support/support_shared_allocate.c
+@@ -0,0 +1,57 @@
++/* Allocate a memory region shared across processes.
++   Copyright (C) 2017 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 <errno.h>
++#include <stddef.h>
++#include <support/support.h>
++#include <support/xunistd.h>
++#include <sys/mman.h>
++
++/* Header for the allocation.  It contains the size of the allocation
++   for subsequent unmapping.  */
++struct header
++{
++  size_t total_size;
++  char data[] __attribute__ ((aligned (__alignof__ (max_align_t))));
++};
++
++void *
++support_shared_allocate (size_t size)
++{
++  size_t total_size = size + offsetof (struct header, data);
++  if (total_size < size)
++    {
++      errno = ENOMEM;
++      oom_error (__func__, size);
++      return NULL;
++    }
++  else
++    {
++      struct header *result = xmmap (NULL, total_size, PROT_READ | PROT_WRITE,
++                                     MAP_ANONYMOUS | MAP_SHARED, -1);
++      result->total_size = total_size;
++      return &result->data;
++    }
++}
++
++void
++support_shared_free (void *data)
++{
++  struct header *header = data - offsetof (struct header, data);
++  xmunmap (header, header->total_size);
++}
+diff --git a/support/support_test_main.c b/support/support_test_main.c
+new file mode 100644
+index 0000000000..914d64f603
+--- /dev/null
++++ b/support/support_test_main.c
+@@ -0,0 +1,423 @@
++/* Main worker function for the test driver.
++   Copyright (C) 1998-2017 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 <support/test-driver.h>
++#include <support/check.h>
++#include <support/temp_file-internal.h>
++
++#include <assert.h>
++#include <errno.h>
++#include <getopt.h>
++#include <malloc.h>
++#include <signal.h>
++#include <stdbool.h>
++#include <stdlib.h>
++#include <string.h>
++#include <sys/param.h>
++#include <sys/resource.h>
++#include <sys/types.h>
++#include <sys/wait.h>
++#include <time.h>
++#include <unistd.h>
++
++static const struct option default_options[] =
++{
++  TEST_DEFAULT_OPTIONS
++  { NULL, 0, NULL, 0 }
++};
++
++/* Show people how to run the program.  */
++static void
++usage (const struct option *options)
++{
++  size_t i;
++
++  printf ("Usage: %s [options]\n"
++          "\n"
++          "Environment Variables:\n"
++          "  TIMEOUTFACTOR          An integer used to scale the timeout\n"
++          "  TMPDIR                 Where to place temporary files\n"
++          "  TEST_COREDUMPS         Do not disable coredumps if set\n"
++          "\n",
++          program_invocation_short_name);
++  printf ("Options:\n");
++  for (i = 0; options[i].name; ++i)
++    {
++      int indent;
++
++      indent = printf ("  --%s", options[i].name);
++      if (options[i].has_arg == required_argument)
++        indent += printf (" <arg>");
++      printf ("%*s", 25 - indent, "");
++      switch (options[i].val)
++        {
++        case 'v':
++          printf ("Increase the output verbosity");
++          break;
++        case OPT_DIRECT:
++          printf ("Run the test directly (instead of forking & monitoring)");
++          break;
++        case OPT_TESTDIR:
++          printf ("Override the TMPDIR env var");
++          break;
++        }
++      printf ("\n");
++    }
++}
++
++/* The PID of the test process.  */
++static pid_t test_pid;
++
++/* The cleanup handler passed to test_main.  */
++static void (*cleanup_function) (void);
++
++/* Timeout handler.  We kill the child and exit with an error.  */
++static void
++__attribute__ ((noreturn))
++signal_handler (int sig)
++{
++  int killed;
++  int status;
++
++  assert (test_pid > 1);
++  /* Kill the whole process group.  */
++  kill (-test_pid, SIGKILL);
++  /* In case setpgid failed in the child, kill it individually too.  */
++  kill (test_pid, SIGKILL);
++
++  /* Wait for it to terminate.  */
++  int i;
++  for (i = 0; i < 5; ++i)
++    {
++      killed = waitpid (test_pid, &status, WNOHANG|WUNTRACED);
++      if (killed != 0)
++        break;
++
++      /* Delay, give the system time to process the kill.  If the
++         nanosleep() call return prematurely, all the better.  We
++         won't restart it since this probably means the child process
++         finally died.  */
++      struct timespec ts;
++      ts.tv_sec = 0;
++      ts.tv_nsec = 100000000;
++      nanosleep (&ts, NULL);
++    }
++  if (killed != 0 && killed != test_pid)
++    {
++      printf ("Failed to kill test process: %m\n");
++      exit (1);
++    }
++
++  if (cleanup_function != NULL)
++    cleanup_function ();
++
++  if (sig == SIGINT)
++    {
++      signal (sig, SIG_DFL);
++      raise (sig);
++    }
++
++  if (killed == 0 || (WIFSIGNALED (status) && WTERMSIG (status) == SIGKILL))
++    puts ("Timed out: killed the child process");
++  else if (WIFSTOPPED (status))
++    printf ("Timed out: the child process was %s\n",
++            strsignal (WSTOPSIG (status)));
++  else if (WIFSIGNALED (status))
++    printf ("Timed out: the child process got signal %s\n",
++            strsignal (WTERMSIG (status)));
++  else
++    printf ("Timed out: killed the child process but it exited %d\n",
++            WEXITSTATUS (status));
++
++  /* Exit with an error.  */
++  exit (1);
++}
++
++/* Run test_function or test_function_argv.  */
++static int
++run_test_function (int argc, char **argv, const struct test_config *config)
++{
++  if (config->test_function != NULL)
++    return config->test_function ();
++  else if (config->test_function_argv != NULL)
++    return config->test_function_argv (argc, argv);
++  else
++    {
++      printf ("error: no test function defined\n");
++      exit (1);
++    }
++}
++
++static bool test_main_called;
++
++const char *test_dir = NULL;
++unsigned int test_verbose = 0;
++
++/* If test failure reporting has been linked in, it may contribute
++   additional test failures.  */
++static int
++adjust_exit_status (int status)
++{
++  if (support_report_failure != NULL)
++    return support_report_failure (status);
++  return status;
++}
++
++int
++support_test_main (int argc, char **argv, const struct test_config *config)
++{
++  if (test_main_called)
++    {
++      printf ("error: test_main called for a second time\n");
++      exit (1);
++    }
++  test_main_called = true;
++  const struct option *options;
++  if (config->options != NULL)
++    options = config->options;
++  else
++    options = default_options;
++
++  cleanup_function = config->cleanup_function;
++
++  int direct = 0;       /* Directly call the test function?  */
++  int status;
++  int opt;
++  unsigned int timeoutfactor = 1;
++  pid_t termpid;
++
++  if (!config->no_mallopt)
++    {
++      /* Make uses of freed and uninitialized memory known.  Do not
++         pull in a definition for mallopt if it has not been defined
++         already.  */
++      extern __typeof__ (mallopt) mallopt __attribute__ ((weak));
++      if (mallopt != NULL)
++        mallopt (M_PERTURB, 42);
++    }
++
++  while ((opt = getopt_long (argc, argv, "+", options, NULL)) != -1)
++    switch (opt)
++      {
++      case '?':
++        usage (options);
++        exit (1);
++      case 'v':
++        ++test_verbose;
++        break;
++      case OPT_DIRECT:
++        direct = 1;
++        break;
++      case OPT_TESTDIR:
++        test_dir = optarg;
++        break;
++      default:
++        if (config->cmdline_function != NULL)
++          config->cmdline_function (opt);
++      }
++
++  /* If set, read the test TIMEOUTFACTOR value from the environment.
++     This value is used to scale the default test timeout values. */
++  char *envstr_timeoutfactor = getenv ("TIMEOUTFACTOR");
++  if (envstr_timeoutfactor != NULL)
++    {
++      char *envstr_conv = envstr_timeoutfactor;
++      unsigned long int env_fact;
++
++      env_fact = strtoul (envstr_timeoutfactor, &envstr_conv, 0);
++      if (*envstr_conv == '\0' && envstr_conv != envstr_timeoutfactor)
++        timeoutfactor = MAX (env_fact, 1);
++    }
++
++  /* Set TMPDIR to specified test directory.  */
++  if (test_dir != NULL)
++    {
++      setenv ("TMPDIR", test_dir, 1);
++
++      if (chdir (test_dir) < 0)
++        {
++          printf ("chdir: %m\n");
++          exit (1);
++        }
++    }
++  else
++    {
++      test_dir = getenv ("TMPDIR");
++      if (test_dir == NULL || test_dir[0] == '\0')
++        test_dir = "/tmp";
++    }
++  if (support_set_test_dir != NULL)
++    support_set_test_dir (test_dir);
++
++  int timeout = config->timeout;
++  if (timeout == 0)
++    timeout =  DEFAULT_TIMEOUT;
++
++  /* Make sure we see all message, even those on stdout.  */
++  setvbuf (stdout, NULL, _IONBF, 0);
++
++  /* Make sure temporary files are deleted.  */
++  if (support_delete_temp_files != NULL)
++      atexit (support_delete_temp_files);
++
++  /* Correct for the possible parameters.  */
++  argv[optind - 1] = argv[0];
++  argv += optind - 1;
++  argc -= optind - 1;
++
++  /* Call the initializing function, if one is available.  */
++  if (config->prepare_function != NULL)
++    config->prepare_function (argc, argv);
++
++  const char *envstr_direct = getenv ("TEST_DIRECT");
++  if (envstr_direct != NULL)
++    {
++      FILE *f = fopen (envstr_direct, "w");
++      if (f == NULL)
++        {
++          printf ("cannot open TEST_DIRECT output file '%s': %m\n",
++                  envstr_direct);
++          exit (1);
++        }
++
++      fprintf (f, "timeout=%u\ntimeoutfactor=%u\n",
++               config->timeout, timeoutfactor);
++      if (config->expected_status != 0)
++        fprintf (f, "exit=%u\n", config->expected_status);
++      if (config->expected_signal != 0)
++        fprintf (f, "signal=%s\n", strsignal (config->expected_signal));
++
++      if (support_print_temp_files != NULL)
++        support_print_temp_files (f);
++
++      fclose (f);
++      direct = 1;
++    }
++
++  bool disable_coredumps;
++  {
++    const char *coredumps = getenv ("TEST_COREDUMPS");
++    disable_coredumps = coredumps == NULL || coredumps[0] == '\0';
++  }
++
++  /* If we are not expected to fork run the function immediately.  */
++  if (direct)
++    return adjust_exit_status (run_test_function (argc, argv, config));
++
++  /* Set up the test environment:
++     - prevent core dumps
++     - set up the timer
++     - fork and execute the function.  */
++
++  test_pid = fork ();
++  if (test_pid == 0)
++    {
++      /* This is the child.  */
++      if (disable_coredumps)
++        {
++          /* Try to avoid dumping core.  This is necessary because we
++             run the test from the source tree, and the coredumps
++             would end up there (and not in the build tree).  */
++          struct rlimit core_limit;
++          core_limit.rlim_cur = 0;
++          core_limit.rlim_max = 0;
++          setrlimit (RLIMIT_CORE, &core_limit);
++        }
++
++      /* We put the test process in its own pgrp so that if it bogusly
++         generates any job control signals, they won't hit the whole build.  */
++      if (setpgid (0, 0) != 0)
++        printf ("Failed to set the process group ID: %m\n");
++
++      /* Execute the test function and exit with the return value.   */
++      exit (run_test_function (argc, argv, config));
++    }
++  else if (test_pid < 0)
++    {
++      printf ("Cannot fork test program: %m\n");
++      exit (1);
++    }
++
++  /* Set timeout.  */
++  signal (SIGALRM, signal_handler);
++  alarm (timeout * timeoutfactor);
++
++  /* Make sure we clean up if the wrapper gets interrupted.  */
++  signal (SIGINT, signal_handler);
++
++  /* Wait for the regular termination.  */
++  termpid = TEMP_FAILURE_RETRY (waitpid (test_pid, &status, 0));
++  if (termpid == -1)
++    {
++      printf ("Waiting for test program failed: %m\n");
++      exit (1);
++    }
++  if (termpid != test_pid)
++    {
++      printf ("Oops, wrong test program terminated: expected %ld, got %ld\n",
++              (long int) test_pid, (long int) termpid);
++      exit (1);
++    }
++
++  /* Process terminated normaly without timeout etc.  */
++  if (WIFEXITED (status))
++    {
++      if (config->expected_status == 0)
++        {
++          if (config->expected_signal == 0)
++            /* Exit with the return value of the test.  */
++            return adjust_exit_status (WEXITSTATUS (status));
++          else
++            {
++              printf ("Expected signal '%s' from child, got none\n",
++                      strsignal (config->expected_signal));
++              exit (1);
++            }
++        }
++      else
++        {
++          /* Non-zero exit status is expected */
++          if (WEXITSTATUS (status) != config->expected_status)
++            {
++              printf ("Expected status %d, got %d\n",
++                      config->expected_status, WEXITSTATUS (status));
++              exit (1);
++            }
++        }
++      return adjust_exit_status (0);
++    }
++  /* Process was killed by timer or other signal.  */
++  else
++    {
++      if (config->expected_signal == 0)
++        {
++          printf ("Didn't expect signal from child: got `%s'\n",
++                  strsignal (WTERMSIG (status)));
++          exit (1);
++        }
++      else if (WTERMSIG (status) != config->expected_signal)
++        {
++          printf ("Incorrect signal from child: got `%s', need `%s'\n",
++                  strsignal (WTERMSIG (status)),
++                  strsignal (config->expected_signal));
++          exit (1);
++        }
++
++      return adjust_exit_status (0);
++    }
++}
+diff --git a/support/support_test_verify_impl.c b/support/support_test_verify_impl.c
+new file mode 100644
+index 0000000000..5bae38f8b1
+--- /dev/null
++++ b/support/support_test_verify_impl.c
+@@ -0,0 +1,33 @@
++/* Implementation of the TEST_VERIFY and TEST_VERIFY_EXIT macros.
++   Copyright (C) 2016-2017 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 <support/check.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++
++void
++support_test_verify_impl (int status, const char *file, int line,
++                          const char *expr)
++{
++  support_record_failure ();
++  printf ("error: %s:%d: not true: %s\n", file, line, expr);
++  if (status >= 0)
++    exit (status);
++
++}
+diff --git a/support/support_write_file_string.c b/support/support_write_file_string.c
+new file mode 100644
+index 0000000000..48e89597f3
+--- /dev/null
++++ b/support/support_write_file_string.c
+@@ -0,0 +1,39 @@
++/* Write a string to a file.
++   Copyright (C) 2017 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 <fcntl.h>
++#include <string.h>
++#include <support/check.h>
++#include <xunistd.h>
++
++void
++support_write_file_string (const char *path, const char *contents)
++{
++  int fd = xopen (path, O_CREAT | O_TRUNC | O_WRONLY, 0666);
++  const char *end = contents + strlen (contents);
++  for (const char *p = contents; p < end; )
++    {
++      ssize_t ret = write (fd, p, end - p);
++      if (ret < 0)
++        FAIL_EXIT1 ("cannot write to \"%s\": %m", path);
++      if (ret == 0)
++        FAIL_EXIT1 ("zero-length write to \"%s\"", path);
++      p += ret;
++    }
++  xclose (fd);
++}
+diff --git a/support/temp_file-internal.h b/support/temp_file-internal.h
+new file mode 100644
+index 0000000000..fb6cceb065
+--- /dev/null
++++ b/support/temp_file-internal.h
+@@ -0,0 +1,31 @@
++/* Internal weak declarations for temporary file handling.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_TEMP_FILE_INTERNAL_H
++#define SUPPORT_TEMP_FILE_INTERNAL_H
++
++/* These functions are called by the test driver if they are
++   defined.  Tests should not call them directly.  */
++
++#include <stdio.h>
++
++void support_set_test_dir (const char *name) __attribute__ ((weak));
++void support_delete_temp_files (void) __attribute__ ((weak));
++void support_print_temp_files (FILE *) __attribute__ ((weak));
++
++#endif /* SUPPORT_TEMP_FILE_INTERNAL_H */
+diff --git a/support/temp_file.c b/support/temp_file.c
+new file mode 100644
+index 0000000000..fdb2477ab9
+--- /dev/null
++++ b/support/temp_file.c
+@@ -0,0 +1,132 @@
++/* Temporary file handling for tests.
++   Copyright (C) 1998-2017 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 is required to get an mkstemp which can create large files on
++   some 32-bit platforms. */
++#define _FILE_OFFSET_BITS 64
++
++#include <support/temp_file.h>
++#include <support/temp_file-internal.h>
++#include <support/support.h>
++
++#include <paths.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include <unistd.h>
++
++/* List of temporary files.  */
++static struct temp_name_list
++{
++  struct temp_name_list *next;
++  char *name;
++  pid_t owner;
++} *temp_name_list;
++
++/* Location of the temporary files.  Set by the test skeleton via
++   support_set_test_dir.  The string is not be freed.  */
++static const char *test_dir = _PATH_TMP;
++
++void
++add_temp_file (const char *name)
++{
++  struct temp_name_list *newp
++    = (struct temp_name_list *) xcalloc (sizeof (*newp), 1);
++  char *newname = strdup (name);
++  if (newname != NULL)
++    {
++      newp->name = newname;
++      newp->next = temp_name_list;
++      newp->owner = getpid ();
++      temp_name_list = newp;
++    }
++  else
++    free (newp);
++}
++
++int
++create_temp_file (const char *base, char **filename)
++{
++  char *fname;
++  int fd;
++
++  fname = (char *) xmalloc (strlen (test_dir) + 1 + strlen (base)
++			    + sizeof ("XXXXXX"));
++  strcpy (stpcpy (stpcpy (stpcpy (fname, test_dir), "/"), base), "XXXXXX");
++
++  fd = mkstemp (fname);
++  if (fd == -1)
++    {
++      printf ("cannot open temporary file '%s': %m\n", fname);
++      free (fname);
++      return -1;
++    }
++
++  add_temp_file (fname);
++  if (filename != NULL)
++    *filename = fname;
++  else
++    free (fname);
++
++  return fd;
++}
++
++/* Helper functions called by the test skeleton follow.  */
++
++void
++support_set_test_dir (const char *path)
++{
++  test_dir = path;
++}
++
++void
++support_delete_temp_files (void)
++{
++  pid_t pid = getpid ();
++  while (temp_name_list != NULL)
++    {
++      /* Only perform the removal if the path was registed in the same
++	 process, as identified by the PID.  (This assumes that the
++	 parent process which registered the temporary file sticks
++	 around, to prevent PID reuse.)  */
++      if (temp_name_list->owner == pid)
++	{
++	  if (remove (temp_name_list->name) != 0)
++	    printf ("warning: could not remove temporary file: %s: %m\n",
++		    temp_name_list->name);
++	}
++      free (temp_name_list->name);
++
++      struct temp_name_list *next = temp_name_list->next;
++      free (temp_name_list);
++      temp_name_list = next;
++    }
++}
++
++void
++support_print_temp_files (FILE *f)
++{
++  if (temp_name_list != NULL)
++    {
++      struct temp_name_list *n;
++      fprintf (f, "temp_files=(\n");
++      for (n = temp_name_list; n != NULL; n = n->next)
++        fprintf (f, "  '%s'\n", n->name);
++      fprintf (f, ")\n");
++    }
++}
+diff --git a/support/temp_file.h b/support/temp_file.h
+new file mode 100644
+index 0000000000..6fed8df1ea
+--- /dev/null
++++ b/support/temp_file.h
+@@ -0,0 +1,37 @@
++/* Declarations for temporary file handling.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_TEMP_FILE_H
++#define SUPPORT_TEMP_FILE_H
++
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++/* Schedule a temporary file for deletion on exit.  */
++void add_temp_file (const char *name);
++
++/* Create a temporary file.  Return the opened file descriptor on
++   success, or -1 on failure.  Write the file name to *FILENAME if
++   FILENAME is not NULL.  In this case, the caller is expected to free
++   *FILENAME.  */
++int create_temp_file (const char *base, char **filename);
++
++__END_DECLS
++
++#endif /* SUPPORT_TEMP_FILE_H */
+diff --git a/support/test-driver.c b/support/test-driver.c
+new file mode 100644
+index 0000000000..482066dbeb
+--- /dev/null
++++ b/support/test-driver.c
+@@ -0,0 +1,156 @@
++/* Main function for test programs.
++   Copyright (C) 2016-2017 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 should be included from test cases.  It will define a
++   main function which provides the test wrapper.
++
++   It assumes that the test case defines a function
++
++     int do_test (void);
++
++   and arranges for that function being called under the test wrapper.
++   The do_test function should return 0 to indicate a passing test, 1
++   to indicate a failing test, or 77 to indicate an unsupported test.
++   Other result values could be used to indicate a failing test, but
++   the result of the expression is passed to exit and exit only
++   returns the lower 8 bits of its input.  A non-zero return with some
++   values could cause a test to incorrectly be considered passing when
++   it really failed.  For this reason, the function should always
++   return 0 (EXIT_SUCCESS), 1 (EXIT_FAILURE), or 77
++   (EXIT_UNSUPPORTED).
++
++   The test function may print out diagnostic or warning messages as well
++   as messages about failures.  These messages should be printed to stdout
++   and not stderr so that the output is properly ordered with respect to
++   the rest of the glibc testsuite run output.
++
++   Several preprocessors macros can be defined before including this
++   file.
++
++   The name of the do_test function can be changed with the
++   TEST_FUNCTION macro.  It must expand to the desired function name.
++
++   If the test case needs access to command line parameters, it must
++   define the TEST_FUNCTION_ARGV macro with the name of the test
++   function.  It must have the following type:
++
++     int TEST_FUNCTION_ARGV (int argc, char **argv);
++
++   This overrides the do_test default function and is incompatible
++   with the TEST_FUNCTION macro.
++
++   If PREPARE is defined, it must expand to the name of a function of
++   the type
++
++     void PREPARE (int argc, char **);
++
++   This function will be called early, after parsing the command line,
++   but before running the test, in the parent process which acts as
++   the test supervisor.
++
++   If CLEANUP_HANDLER is defined, it must expand to the name of a
++   function of the type
++
++     void CLEANUP_HANDLER (void);
++
++   This function will be called from the timeout (SIGALRM) signal
++   handler.
++
++   If EXPECTED_SIGNAL is defined, it must expanded to a constant which
++   denotes the expected signal number.
++
++   If EXPECTED_STATUS is defined, it must expand to the expected exit
++   status.
++
++   If TIMEOUT is defined, it must be positive constant.  It overrides
++   the default test timeout and is measured in seconds.
++
++   If TEST_NO_MALLOPT is defined, the test wrapper will not call
++   mallopt.
++
++   Custom command line handling can be implemented by defining the
++   CMDLINE_OPTION macro (after including the <getopt.h> header; this
++   requires _GNU_SOURCE to be defined).  This macro must expand to a
++   to a comma-separated list of braced initializers for struct option
++   from <getopt.h>, with a trailing comma.  CMDLINE_PROCESS can be
++   defined as the name of a function which is called to process these
++   options.  The function is passed the option character/number and
++   has this type:
++
++     void CMDLINE_PROCESS (int);
++*/
++
++#include <support/test-driver.h>
++
++#include <string.h>
++
++int
++main (int argc, char **argv)
++{
++  struct test_config test_config;
++  memset (&test_config, 0, sizeof (test_config));
++
++#ifdef PREPARE
++  test_config.prepare_function = (PREPARE);
++#endif
++
++#if defined (TEST_FUNCTION) && defined (TEST_FUNCTON_ARGV)
++# error TEST_FUNCTION and TEST_FUNCTION_ARGV cannot be defined at the same time
++#endif
++#if defined (TEST_FUNCTION)
++  test_config.test_function = TEST_FUNCTION;
++#elif defined (TEST_FUNCTION_ARGV)
++  test_config.test_function_argv = TEST_FUNCTION_ARGV;
++#else
++  test_config.test_function = do_test;
++#endif
++
++#ifdef CLEANUP_HANDLER
++  test_config.cleanup_function = CLEANUP_HANDLER;
++#endif
++
++#ifdef EXPECTED_SIGNAL
++  test_config.expected_signal = (EXPECTED_SIGNAL);
++#endif
++
++#ifdef EXPECTED_STATUS
++  test_config.expected_status = (EXPECTED_STATUS);
++#endif
++
++#ifdef TEST_NO_MALLOPT
++  test_config.no_mallopt = 1;
++#endif
++
++#ifdef TIMEOUT
++  test_config.timeout = TIMEOUT;
++#endif
++
++#ifdef CMDLINE_OPTIONS
++  struct option options[] =
++    {
++      CMDLINE_OPTIONS
++      TEST_DEFAULT_OPTIONS
++    };
++  test_config.options = &options;
++#endif
++#ifdef CMDLINE_PROCESS
++  test_config.cmdline_function = CMDLINE_PROCESS;
++#endif
++
++  return support_test_main (argc, argv, &test_config);
++}
+diff --git a/support/test-driver.h b/support/test-driver.h
+new file mode 100644
+index 0000000000..af1971a9ca
+--- /dev/null
++++ b/support/test-driver.h
+@@ -0,0 +1,74 @@
++/* Interfaces for the test driver.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_TEST_DRIVER_H
++#define SUPPORT_TEST_DRIVER_H
++
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++struct test_config
++{
++  void (*prepare_function) (int argc, char **argv);
++  int (*test_function) (void);
++  int (*test_function_argv) (int argc, char **argv);
++  void (*cleanup_function) (void);
++  void (*cmdline_function) (int);
++  const void *options;   /* Custom options if not NULL.  */
++  int timeout;           /* Test timeout in seconds.  */
++  int expected_status;   /* Expected exit status.  */
++  int expected_signal;   /* If non-zero, expect termination by signal.  */
++  char no_mallopt;       /* Boolean flag to disable mallopt.  */
++};
++
++enum
++  {
++    /* Test exit status which indicates that the feature is
++       unsupported. */
++    EXIT_UNSUPPORTED = 77,
++
++    /* Default timeout is twenty seconds.  Tests should normally
++       complete faster than this, but if they don't, that's abnormal
++       (a bug) anyways.  */
++    DEFAULT_TIMEOUT = 20,
++
++    /* Used for command line argument parsing.  */
++    OPT_DIRECT = 1000,
++    OPT_TESTDIR,
++  };
++
++/* Options provided by the test driver.  */
++#define TEST_DEFAULT_OPTIONS                            \
++  { "verbose", no_argument, NULL, 'v' },                \
++  { "direct", no_argument, NULL, OPT_DIRECT },          \
++  { "test-dir", required_argument, NULL, OPT_TESTDIR }, \
++
++/* The directory the test should use for temporary files.  */
++extern const char *test_dir;
++
++/* The number of --verbose arguments specified during program
++   invocation.  This variable can be used to control the verbosity of
++   tests.  */
++extern unsigned int test_verbose;
++
++int support_test_main (int argc, char **argv, const struct test_config *);
++
++__END_DECLS
++
++#endif /* SUPPORT_TEST_DRIVER_H */
+diff --git a/support/tst-support-namespace.c b/support/tst-support-namespace.c
+new file mode 100644
+index 0000000000..a50b074f5e
+--- /dev/null
++++ b/support/tst-support-namespace.c
+@@ -0,0 +1,34 @@
++/* Test entering namespaces.
++   Copyright (C) 2016-2017 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 <stdio.h>
++#include <support/namespace.h>
++
++static int
++do_test (void)
++{
++  if (support_become_root ())
++    printf ("info: acquired root-like privileges\n");
++  if (support_enter_network_namespace ())
++    printf ("info: entered network namespace\n");
++  if (support_in_uts_namespace ())
++    printf ("info: also entered UTS namespace\n");
++  return 0;
++}
++
++#include <support/test-driver.c>
+diff --git a/support/tst-support_capture_subprocess.c b/support/tst-support_capture_subprocess.c
+new file mode 100644
+index 0000000000..5672fba0f7
+--- /dev/null
++++ b/support/tst-support_capture_subprocess.c
+@@ -0,0 +1,188 @@
++/* Test capturing output from a subprocess.
++   Copyright (C) 2017 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 <stdbool.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include <support/capture_subprocess.h>
++#include <support/check.h>
++#include <support/support.h>
++#include <sys/wait.h>
++#include <unistd.h>
++
++/* Write one byte at *P to FD and advance *P.  Do nothing if *P is
++   '\0'.  */
++static void
++transfer (const unsigned char **p, int fd)
++{
++  if (**p != '\0')
++    {
++      TEST_VERIFY (write (fd, *p, 1) == 1);
++      ++*p;
++    }
++}
++
++/* Determine the order in which stdout and stderr are written.  */
++enum write_mode { out_first, err_first, interleave,
++                  write_mode_last =  interleave };
++
++/* Describe what to write in the subprocess.  */
++struct test
++{
++  char *out;
++  char *err;
++  enum write_mode write_mode;
++  int signal;
++  int status;
++};
++
++/* For use with support_capture_subprocess.  */
++static void
++callback (void *closure)
++{
++  const struct test *test = closure;
++  bool mode_ok = false;
++  switch (test->write_mode)
++    {
++    case out_first:
++      TEST_VERIFY (fputs (test->out, stdout) >= 0);
++      TEST_VERIFY (fflush (stdout) == 0);
++      TEST_VERIFY (fputs (test->err, stderr) >= 0);
++      TEST_VERIFY (fflush (stderr) == 0);
++      mode_ok = true;
++      break;
++    case err_first:
++      TEST_VERIFY (fputs (test->err, stderr) >= 0);
++      TEST_VERIFY (fflush (stderr) == 0);
++      TEST_VERIFY (fputs (test->out, stdout) >= 0);
++      TEST_VERIFY (fflush (stdout) == 0);
++      mode_ok = true;
++      break;
++    case interleave:
++      {
++        const unsigned char *pout = (const unsigned char *) test->out;
++        const unsigned char *perr = (const unsigned char *) test->err;
++        do
++          {
++            transfer (&pout, STDOUT_FILENO);
++            transfer (&perr, STDERR_FILENO);
++          }
++        while (*pout != '\0' || *perr != '\0');
++      }
++      mode_ok = true;
++      break;
++    }
++  TEST_VERIFY (mode_ok);
++
++  if (test->signal != 0)
++    raise (test->signal);
++  exit (test->status);
++}
++
++/* Create a heap-allocated random string of letters.  */
++static char *
++random_string (size_t length)
++{
++  char *result = xmalloc (length + 1);
++  for (size_t i = 0; i < length; ++i)
++    result[i] = 'a' + (rand () % 26);
++  result[length] = '\0';
++  return result;
++}
++
++/* Check that the specific stream from the captured subprocess matches
++   expectations.  */
++static void
++check_stream (const char *what, const struct xmemstream *stream,
++              const char *expected)
++{
++  if (strcmp (stream->buffer, expected) != 0)
++    {
++      support_record_failure ();
++      printf ("error: captured %s data incorrect\n"
++              "  expected: %s\n"
++              "  actual:   %s\n",
++              what, expected, stream->buffer);
++    }
++  if (stream->length != strlen (expected))
++    {
++      support_record_failure ();
++      printf ("error: captured %s data length incorrect\n"
++              "  expected: %zu\n"
++              "  actual:   %zu\n",
++              what, strlen (expected), stream->length);
++    }
++}
++
++static int
++do_test (void)
++{
++  const int lengths[] = {0, 1, 17, 512, 20000, -1};
++
++  /* Test multiple combinations of support_capture_subprocess.
++
++     length_idx_stdout: Index into the lengths array above,
++       controls how many bytes are written by the subprocess to
++       standard output.
++     length_idx_stderr: Same for standard error.
++     write_mode: How standard output and standard error writes are
++       ordered.
++     signal: Exit with no signal if zero, with SIGTERM if one.
++     status: Process exit status: 0 if zero, 3 if one.  */
++  for (int length_idx_stdout = 0; lengths[length_idx_stdout] >= 0;
++       ++length_idx_stdout)
++    for (int length_idx_stderr = 0; lengths[length_idx_stderr] >= 0;
++         ++length_idx_stderr)
++      for (int write_mode = 0; write_mode < write_mode_last; ++write_mode)
++        for (int signal = 0; signal < 2; ++signal)
++          for (int status = 0; status < 2; ++status)
++            {
++              struct test test =
++                {
++                  .out = random_string (lengths[length_idx_stdout]),
++                  .err = random_string (lengths[length_idx_stderr]),
++                  .write_mode = write_mode,
++                  .signal = signal * SIGTERM, /* 0 or SIGTERM.  */
++                  .status = status * 3,       /* 0 or 3.  */
++                };
++              TEST_VERIFY (strlen (test.out) == lengths[length_idx_stdout]);
++              TEST_VERIFY (strlen (test.err) == lengths[length_idx_stderr]);
++
++              struct support_capture_subprocess result
++                = support_capture_subprocess (callback, &test);
++              check_stream ("stdout", &result.out, test.out);
++              check_stream ("stderr", &result.err, test.err);
++              if (test.signal != 0)
++                {
++                  TEST_VERIFY (WIFSIGNALED (result.status));
++                  TEST_VERIFY (WTERMSIG (result.status) == test.signal);
++                }
++              else
++                {
++                  TEST_VERIFY (WIFEXITED (result.status));
++                  TEST_VERIFY (WEXITSTATUS (result.status) == test.status);
++                }
++              support_capture_subprocess_free (&result);
++              free (test.out);
++              free (test.err);
++            }
++  return 0;
++}
++
++#include <support/test-driver.c>
+diff --git a/support/tst-support_format_dns_packet.c b/support/tst-support_format_dns_packet.c
+new file mode 100644
+index 0000000000..9c8589c09c
+--- /dev/null
++++ b/support/tst-support_format_dns_packet.c
+@@ -0,0 +1,101 @@
++/* Tests for the support_format_dns_packet function.
++   Copyright (C) 2016-2017 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 <support/check.h>
++#include <support/format_nss.h>
++#include <support/run_diff.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++
++static void
++check_packet (const void *buffer, size_t length,
++              const char *name, const char *expected)
++{
++  char *actual = support_format_dns_packet (buffer, length);
++  if (strcmp (actual, expected) != 0)
++    {
++      support_record_failure ();
++      printf ("error: formatted packet does not match: %s\n", name);
++      support_run_diff ("expected", expected,
++                        "actual", actual);
++    }
++  free (actual);
++}
++
++static void
++test_aaaa_length (void)
++{
++  static const char packet[] =
++    /* Header: Response with two records.  */
++    "\x12\x34\x80\x00\x00\x01\x00\x02\x00\x00\x00\x00"
++    /* Question section.  www.example/IN/AAAA.  */
++    "\x03www\x07""example\x00\x00\x1c\x00\x01"
++    /* Answer section.  www.example AAAA [corrupted].  */
++    "\xc0\x0c"
++    "\x00\x1c\x00\x01\x00\x00\x00\x00\x00\x10"
++    "\x20\x01\x0d\xb8\x05\x06\x07\x08"
++    "\x11\x12\x13\x14\x15\x16\x17\x18"
++    /* www.example AAAA [corrupted].  */
++    "\xc0\x0c"
++    "\x00\x1c\x00\x01\x00\x00\x00\x00\x00\x11"
++    "\x01\x02\x03\x04\x05\x06\x07\x08"
++    "\x11\x12\x13\x14\x15\x16\x17\x18" "\xff";
++  check_packet (packet, sizeof (packet) - 1, __func__,
++                "name: www.example\n"
++                "address: 2001:db8:506:708:1112:1314:1516:1718\n"
++                "error: AAAA record of size 17: www.example\n");
++}
++
++static void
++test_multiple_cnames (void)
++{
++  static const char packet[] =
++    /* Header: Response with three records.  */
++    "\x12\x34\x80\x00\x00\x01\x00\x03\x00\x00\x00\x00"
++    /* Question section.  www.example/IN/A.  */
++    "\x03www\x07""example\x00\x00\x01\x00\x01"
++    /* Answer section.  www.example CNAME www1.example.  */
++    "\xc0\x0c"
++    "\x00\x05\x00\x01\x00\x00\x00\x00\x00\x07"
++    "\x04www1\xc0\x10"
++    /* www1 CNAME www2.  */
++    "\x04www1\xc0\x10"
++    "\x00\x05\x00\x01\x00\x00\x00\x00\x00\x07"
++    "\x04www2\xc0\x10"
++    /* www2 A 192.0.2.1.  */
++    "\x04www2\xc0\x10"
++    "\x00\x01\x00\x01\x00\x00\x00\x00\x00\x04"
++    "\xc0\x00\x02\x01";
++  check_packet (packet, sizeof (packet) - 1, __func__,
++                "name: www.example\n"
++                "name: www1.example\n"
++                "name: www2.example\n"
++                "address: 192.0.2.1\n");
++}
++
++static int
++do_test (void)
++{
++  test_aaaa_length ();
++  test_multiple_cnames ();
++  return 0;
++}
++
++#include <support/test-driver.c>
+diff --git a/support/tst-support_record_failure-2.sh b/support/tst-support_record_failure-2.sh
+new file mode 100644
+index 0000000000..2c9372cc29
+--- /dev/null
++++ b/support/tst-support_record_failure-2.sh
+@@ -0,0 +1,69 @@
++#!/bin/sh
++# Test failure recording (with and without --direct).
++# Copyright (C) 2016-2017 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/>.  */
++
++set -e
++
++common_objpfx=$1; shift
++test_program_prefix_before_env=$1; shift
++run_program_env=$1; shift
++test_program_prefix_after_env=$1; shift
++
++run_test () {
++    expected_status="$1"
++    expected_output="$2"
++    shift 2
++    args="${common_objpfx}support/tst-support_record_failure $*"
++    echo "running: $args"
++    set +e
++    output="$(${test_program_prefix_before_env} \
++		 ${run_program} ${test_program_prefix_after_env} $args)"
++    status=$?
++    set -e
++    echo "  exit status: $status"
++    if test "$output" != "$expected_output" ; then
++	echo "error: unexpected output: $output"
++	exit 1
++    fi
++    if test "$status" -ne "$expected_status" ; then
++	echo "error: exit status $expected_status expected"
++	exit 1
++    fi
++}
++
++different_status () {
++    direct="$1"
++    run_test 1 "error: 1 test failures" $direct --status=0
++    run_test 1 "error: 1 test failures" $direct --status=1
++    run_test 2 "error: 1 test failures" $direct --status=2
++    run_test 1 "error: 1 test failures" $direct --status=77
++    run_test 2 "error: tst-support_record_failure.c:109: not true: false
++error: 1 test failures" $direct --test-verify
++    run_test 2 "error: tst-support_record_failure.c:109: not true: false
++info: execution passed failed TEST_VERIFY
++error: 1 test failures" $direct --test-verify --verbose
++}
++
++different_status
++different_status --direct
++
++run_test 1 "error: tst-support_record_failure.c:116: not true: false
++error: 1 test failures" --test-verify-exit
++# --direct does not print the summary error message if exit is called.
++run_test 1 "error: tst-support_record_failure.c:116: not true: false" \
++	 --direct --test-verify-exit
+diff --git a/support/tst-support_record_failure.c b/support/tst-support_record_failure.c
+new file mode 100644
+index 0000000000..e739e739c3
+--- /dev/null
++++ b/support/tst-support_record_failure.c
+@@ -0,0 +1,153 @@
++/* Test support_record_failure state sharing.
++   Copyright (C) 2016-2017 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 <support/check.h>
++#include <support/support.h>
++#include <support/test-driver.h>
++#include <support/xunistd.h>
++
++#include <getopt.h>
++#include <stdbool.h>
++#include <stdlib.h>
++#include <stdio.h>
++#include <string.h>
++
++static int exit_status_with_failure = -1;
++static bool test_verify;
++static bool test_verify_exit;
++enum
++  {
++    OPT_STATUS = 10001,
++    OPT_TEST_VERIFY,
++    OPT_TEST_VERIFY_EXIT,
++  };
++#define CMDLINE_OPTIONS                                                 \
++  { "status", required_argument, NULL, OPT_STATUS },                    \
++  { "test-verify", no_argument, NULL, OPT_TEST_VERIFY },                \
++  { "test-verify-exit", no_argument, NULL, OPT_TEST_VERIFY_EXIT },
++static void
++cmdline_process (int c)
++{
++  switch (c)
++    {
++    case OPT_STATUS:
++      exit_status_with_failure = atoi (optarg);
++      break;
++    case OPT_TEST_VERIFY:
++      test_verify = true;
++      break;
++    case OPT_TEST_VERIFY_EXIT:
++      test_verify_exit = true;
++      break;
++    }
++}
++#define CMDLINE_PROCESS cmdline_process
++
++static void
++check_failure_reporting (int phase, int zero, int unsupported)
++{
++  int status = support_report_failure (0);
++  if (status != zero)
++    {
++      printf ("real-error (phase %d): support_report_failure (0) == %d\n",
++              phase, status);
++      exit (1);
++    }
++  status = support_report_failure (1);
++  if (status != 1)
++    {
++      printf ("real-error (phase %d): support_report_failure (1) == %d\n",
++              phase, status);
++      exit (1);
++    }
++  status = support_report_failure (2);
++  if (status != 2)
++    {
++      printf ("real-error (phase %d): support_report_failure (2) == %d\n",
++              phase, status);
++      exit (1);
++    }
++  status = support_report_failure (EXIT_UNSUPPORTED);
++  if (status != unsupported)
++    {
++      printf ("real-error (phase %d): "
++              "support_report_failure (EXIT_UNSUPPORTED) == %d\n",
++              phase, status);
++      exit (1);
++    }
++}
++
++static int
++do_test (void)
++{
++  if (exit_status_with_failure >= 0)
++    {
++      /* External invocation with requested error status.  Used by
++         tst-support_report_failure-2.sh.  */
++      support_record_failure ();
++      return exit_status_with_failure;
++    }
++  TEST_VERIFY (true);
++  TEST_VERIFY_EXIT (true);
++  if (test_verify)
++    {
++      TEST_VERIFY (false);
++      if (test_verbose)
++        printf ("info: execution passed failed TEST_VERIFY\n");
++      return 2; /* Expected exit status.  */
++    }
++  if (test_verify_exit)
++    {
++      TEST_VERIFY_EXIT (false);
++      return 3; /* Not reached.  Expected exit status is 1.  */
++    }
++
++  printf ("info: This test tests the test framework.\n"
++          "info: It reports some expected errors on stdout.\n");
++
++  /* Check that the status is passed through unchanged.  */
++  check_failure_reporting (1, 0, EXIT_UNSUPPORTED);
++
++  /* Check state propagation from a subprocess.  */
++  pid_t pid = xfork ();
++  if (pid == 0)
++    {
++      support_record_failure ();
++      _exit (0);
++    }
++  int status;
++  xwaitpid (pid, &status, 0);
++  if (status != 0)
++    {
++      printf ("real-error: incorrect status from subprocess: %d\n", status);
++      return 1;
++    }
++  check_failure_reporting (2, 1, 1);
++
++  /* Also test directly in the parent process.  */
++  support_record_failure_reset ();
++  check_failure_reporting (3, 0, EXIT_UNSUPPORTED);
++  support_record_failure ();
++  check_failure_reporting (4, 1, 1);
++
++  /* We need to mask the failure above.  */
++  support_record_failure_reset ();
++  return 0;
++}
++
++#include <support/test-driver.c>
+diff --git a/sysdeps/unix/sysv/linux/sh/pwrite64.c b/support/write_message.c
+similarity index 68%
+rename from sysdeps/unix/sysv/linux/sh/pwrite64.c
+rename to support/write_message.c
+index 683a5d9886..f03ed931d6 100644
+--- a/sysdeps/unix/sysv/linux/sh/pwrite64.c
++++ b/support/write_message.c
+@@ -1,6 +1,6 @@
+-/* Copyright (C) 1997-2016 Free Software Foundation, Inc.
++/* Write a message to standard output.
++   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by Ralf Baechle <ralf@gnu.org>, 1998.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -16,8 +16,14 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-/* SH4 ABI does not really require argument alignment for 64-bits, but
+-   the kernel interface for pread adds a dummy long argument before the
+-   offset.  */
+-#define __ALIGNMENT_ARG
+-#include <sysdeps/unix/sysv/linux/pwrite64.c>
++#include <support/support.h>
++
++#include <string.h>
++#include <unistd.h>
++
++void
++write_message (const char *message)
++{
++  ssize_t unused __attribute__ ((unused));
++  unused = write (STDOUT_FILENO, message, strlen (message));
++}
+diff --git a/support/xaccept.c b/support/xaccept.c
+new file mode 100644
+index 0000000000..7b25af3b05
+--- /dev/null
++++ b/support/xaccept.c
+@@ -0,0 +1,32 @@
++/* accept with error checking.
++   Copyright (C) 2016-2017 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 <support/xsocket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++int
++xaccept (int fd, struct sockaddr *sa, socklen_t *salen)
++{
++  int clientfd = accept (fd, sa, salen);
++  if (clientfd < 0)
++    FAIL_EXIT1 ("accept (%d): %m", fd);
++  return clientfd;
++}
+diff --git a/support/xaccept4.c b/support/xaccept4.c
+new file mode 100644
+index 0000000000..67dd95e9fb
+--- /dev/null
++++ b/support/xaccept4.c
+@@ -0,0 +1,32 @@
++/* accept4 with error checking.
++   Copyright (C) 2017 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 <support/xsocket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++int
++xaccept4 (int fd, struct sockaddr *sa, socklen_t *salen, int flags)
++{
++  int clientfd = accept4 (fd, sa, salen, flags);
++  if (clientfd < 0)
++    FAIL_EXIT1 ("accept4 (%d, 0x%x): %m", fd, flags);
++  return clientfd;
++}
+diff --git a/support/xasprintf.c b/support/xasprintf.c
+new file mode 100644
+index 0000000000..5157680fa2
+--- /dev/null
++++ b/support/xasprintf.c
+@@ -0,0 +1,36 @@
++/* Error-checking wrapper for asprintf.
++   Copyright (C) 2016-2017 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 <support/support.h>
++
++#include <stdarg.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++char *
++xasprintf (const char *format, ...)
++{
++  va_list ap;
++  va_start (ap, format);
++  char *result;
++  if (vasprintf (&result, format, ap) < 0)
++    FAIL_EXIT1 ("asprintf: %m");
++  va_end (ap);
++  return result;
++}
+diff --git a/support/xbind.c b/support/xbind.c
+new file mode 100644
+index 0000000000..cfc6dd8fa8
+--- /dev/null
++++ b/support/xbind.c
+@@ -0,0 +1,30 @@
++/* bind with error checking.
++   Copyright (C) 2016-2017 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 <support/xsocket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++void
++xbind (int fd, const struct sockaddr *sa, socklen_t sa_len)
++{
++  if (bind (fd, sa, sa_len) != 0)
++    FAIL_EXIT1 ("bind (%d), family %d: %m", fd, sa->sa_family);
++}
+diff --git a/sysdeps/unix/sysv/linux/sh/pread64.c b/support/xcalloc.c
+similarity index 67%
+rename from sysdeps/unix/sysv/linux/sh/pread64.c
+rename to support/xcalloc.c
+index b2e8a25788..135f42dab2 100644
+--- a/sysdeps/unix/sysv/linux/sh/pread64.c
++++ b/support/xcalloc.c
+@@ -1,6 +1,6 @@
+-/* Copyright (C) 1997-2016 Free Software Foundation, Inc.
++/* Error-checking wrapper for calloc.
++   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -16,8 +16,19 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-/* SH4 ABI does not really require argument alignment for 64-bits, but
+-   the kernel interface for pread adds a dummy long argument before the
+-   offset.  */
+-#define __ALIGNMENT_ARG
+-#include <sysdeps/unix/sysv/linux/pread64.c>
++#include <support/support.h>
++
++#include <stdarg.h>
++#include <stdio.h>
++#include <stdlib.h>
++
++void *
++xcalloc (size_t n, size_t s)
++{
++  void *p;
++
++  p = calloc (n, s);
++  if (p == NULL)
++    oom_error ("calloc", n * s);
++  return p;
++}
+diff --git a/support/xchroot.c b/support/xchroot.c
+new file mode 100644
+index 0000000000..abcc299e00
+--- /dev/null
++++ b/support/xchroot.c
+@@ -0,0 +1,28 @@
++/* chroot with error checking.
++   Copyright (C) 2017 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 <support/check.h>
++#include <support/xunistd.h>
++#include <sys/stat.h>
++
++void
++xchroot (const char *path)
++{
++  if (chroot (path) != 0)
++    FAIL_EXIT1 ("chroot (\"%s\"): %m", path);
++}
+diff --git a/support/xclose.c b/support/xclose.c
+new file mode 100644
+index 0000000000..c931e08421
+--- /dev/null
++++ b/support/xclose.c
+@@ -0,0 +1,28 @@
++/* close with error checking.
++   Copyright (C) 2017 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 <support/xunistd.h>
++#include <support/check.h>
++#include <errno.h>
++
++void
++xclose (int fd)
++{
++  if (close (fd) < 0 && errno != EINTR)
++    FAIL_EXIT1 ("close of descriptor %d failed: %m", fd);
++}
+diff --git a/support/xconnect.c b/support/xconnect.c
+new file mode 100644
+index 0000000000..0266dbc643
+--- /dev/null
++++ b/support/xconnect.c
+@@ -0,0 +1,30 @@
++/* connect with error checking.
++   Copyright (C) 2016-2017 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 <support/xsocket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++void
++xconnect (int fd, const struct sockaddr *sa, socklen_t sa_len)
++{
++  if (connect (fd, sa, sa_len) != 0)
++    FAIL_EXIT1 ("connect (%d), family %d: %m", fd, sa->sa_family);
++}
+diff --git a/support/xdup2.c b/support/xdup2.c
+new file mode 100644
+index 0000000000..dc08c94518
+--- /dev/null
++++ b/support/xdup2.c
+@@ -0,0 +1,28 @@
++/* dup2 with error checking.
++   Copyright (C) 2017 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 <support/xunistd.h>
++
++#include <support/check.h>
++
++void
++xdup2 (int from, int to)
++{
++  if (dup2 (from, to) < 0)
++    FAIL_EXIT1 ("dup2 (%d, %d): %m", from, to);
++}
+diff --git a/support/xfclose.c b/support/xfclose.c
+new file mode 100644
+index 0000000000..2737f05044
+--- /dev/null
++++ b/support/xfclose.c
+@@ -0,0 +1,33 @@
++/* fclose with error checking.
++   Copyright (C) 2016-2017 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 <support/xstdio.h>
++
++#include <support/check.h>
++#include <stdlib.h>
++
++void
++xfclose (FILE *fp)
++{
++  if (ferror (fp))
++    FAIL_EXIT1 ("stdio stream closed with pending errors");
++  if (fflush (fp) != 0)
++    FAIL_EXIT1 ("fflush: %m");
++  if (fclose (fp) != 0)
++    FAIL_EXIT1 ("fclose: %m");
++}
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdimf-vis3.S b/support/xfopen.c
+similarity index 67%
+rename from sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdimf-vis3.S
+rename to support/xfopen.c
+index 081fc15b62..14532a09f3 100644
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdimf-vis3.S
++++ b/support/xfopen.c
+@@ -1,7 +1,6 @@
+-/* Compute positive difference, sparc 32-bit+v9+vis3.
+-   Copyright (C) 2013-2016 Free Software Foundation, Inc.
++/* fopen with error checking.
++   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by David S. Miller <davem@davemloft.net>.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -17,16 +16,16 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-#include <sysdep.h>
++#include <support/xstdio.h>
+ 
+-ENTRY(__fdimf_vis3)
+-	movwtos	%o0, %f0
+-	movwtos	%o1, %f1
+-	fcmps	%f0, %f1
+-	fbug	1f
+-	 nop
+-	fzeros	%f0
+-	fnegs	%f0, %f1
+-1:	retl
+-	 fsubs	%f0, %f1, %f0
+-END(__fdimf_vis3)
++#include <support/check.h>
++#include <stdlib.h>
++
++FILE *
++xfopen (const char *path, const char *mode)
++{
++  FILE *fp = fopen (path, mode);
++  if (fp == NULL)
++    FAIL_EXIT1 ("could not open %s (mode \"%s\"): %m", path, mode);
++  return fp;
++}
+diff --git a/support/xfork.c b/support/xfork.c
+new file mode 100644
+index 0000000000..aa52ba62c5
+--- /dev/null
++++ b/support/xfork.c
+@@ -0,0 +1,32 @@
++/* fork with error checking.
++   Copyright (C) 2016-2017 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 <support/xunistd.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++pid_t
++xfork (void)
++{
++  pid_t result = fork ();
++  if (result < 0)
++    FAIL_EXIT1 ("fork: %m");
++  return result;
++}
+diff --git a/support/xgetsockname.c b/support/xgetsockname.c
+new file mode 100644
+index 0000000000..c3bd884f8d
+--- /dev/null
++++ b/support/xgetsockname.c
+@@ -0,0 +1,30 @@
++/* getsockname with error checking.
++   Copyright (C) 2016-2017 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 <support/xsocket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++void
++xgetsockname (int fd, struct sockaddr *sa, socklen_t *plen)
++{
++  if (getsockname (fd, sa, plen) != 0)
++    FAIL_EXIT1 ("setsockopt (%d): %m", fd);
++}
+diff --git a/support/xlisten.c b/support/xlisten.c
+new file mode 100644
+index 0000000000..1953e5900a
+--- /dev/null
++++ b/support/xlisten.c
+@@ -0,0 +1,30 @@
++/* listen with error checking.
++   Copyright (C) 2016-2017 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 <support/xsocket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++void
++xlisten (int fd, int backlog)
++{
++  if (listen (fd, backlog) != 0)
++    FAIL_EXIT1 ("listen (%d, %d): %m", fd, backlog);
++}
+diff --git a/support/xmalloc.c b/support/xmalloc.c
+new file mode 100644
+index 0000000000..450f699789
+--- /dev/null
++++ b/support/xmalloc.c
+@@ -0,0 +1,34 @@
++/* Error-checking wrapper for malloc.
++   Copyright (C) 2016-2017 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 <support/support.h>
++
++#include <stdarg.h>
++#include <stdio.h>
++#include <stdlib.h>
++
++void *
++xmalloc (size_t n)
++{
++  void *p;
++
++  p = malloc (n);
++  if (p == NULL)
++    oom_error ("malloc", n);
++  return p;
++}
+diff --git a/sysdeps/sparc/sparc32/fpu/s_fdim.S b/support/xmemstream.c
+similarity index 54%
+rename from sysdeps/sparc/sparc32/fpu/s_fdim.S
+rename to support/xmemstream.c
+index e93970faae..bce6dc9170 100644
+--- a/sysdeps/sparc/sparc32/fpu/s_fdim.S
++++ b/support/xmemstream.c
+@@ -1,7 +1,6 @@
+-/* Compute positive difference, sparc 32-bit.
+-   Copyright (C) 2013-2016 Free Software Foundation, Inc.
++/* Error-checking wrappers for memstream functions.
++   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by David S. Miller <davem@davemloft.net>.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -17,26 +16,27 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-#include <sysdep.h>
+-#include <math_ldbl_opt.h>
++#include <support/xmemstream.h>
+ 
+-ENTRY(__fdim)
+-	std	%o0, [%sp + 72]
+-	std	%o2, [%sp + 80]
+-	ldd	[%sp + 72], %f0
+-	ldd	[%sp + 80], %f2
+-	fcmpd	%f0, %f2
+-	st	%g0, [%sp + 72]
+-	fbug	1f
+-	 st	%g0, [%sp + 76]
+-	ldd	[%sp + 72], %f0
+-	fnegs	%f0, %f2
+-	fmovs	%f1, %f3
+-1:	retl
+-	 fsubd	%f0, %f2, %f0
+-END(__fdim)
+-weak_alias (__fdim, fdim)
++#include <errno.h>
++#include <stdlib.h>
++#include <support/check.h>
++#include <support/xstdio.h>
+ 
+-#if LONG_DOUBLE_COMPAT(libm, GLIBC_2_1)
+-compat_symbol (libm, __fdim, fdiml, GLIBC_2_1);
+-#endif
++void
++xopen_memstream (struct xmemstream *stream)
++{
++  int old_errno = errno;
++  *stream = (struct xmemstream) {};
++  stream->out = open_memstream (&stream->buffer, &stream->length);
++  if (stream->out == NULL)
++    FAIL_EXIT1 ("open_memstream: %m");
++  errno = old_errno;
++}
++
++void
++xfclose_memstream (struct xmemstream *stream)
++{
++  xfclose (stream->out);
++  stream->out = NULL;
++}
+diff --git a/support/xmemstream.h b/support/xmemstream.h
+new file mode 100644
+index 0000000000..e5ba231e4d
+--- /dev/null
++++ b/support/xmemstream.h
+@@ -0,0 +1,49 @@
++/* Error-checking wrappers for memstream functions.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_XMEMSTREAM_H
++#define SUPPORT_XMEMSTREAM_H
++
++#include <stdio.h>
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++/* Wrappers for other libc functions.  */
++struct xmemstream
++{
++  FILE *out;
++  char *buffer;
++  size_t length;
++};
++
++/* Create a new in-memory stream.  Initializes *STREAM.  After this
++   function returns, STREAM->out is a file descriptor open for
++   writing.  errno is preserved, so that the %m format specifier can
++   be used for writing to STREAM->out.  */
++void xopen_memstream (struct xmemstream *stream);
++
++/* Closes STREAM->OUT.  After this function returns, STREAM->buffer
++   and STREAM->length denote a memory range which contains the bytes
++   written to the output stream.  The caller should free
++   STREAM->buffer.  */
++void xfclose_memstream (struct xmemstream *stream);
++
++__END_DECLS
++
++#endif /* SUPPORT_XMEMSTREAM_H */
+diff --git a/support/xmkdir.c b/support/xmkdir.c
+new file mode 100644
+index 0000000000..ea17d49391
+--- /dev/null
++++ b/support/xmkdir.c
+@@ -0,0 +1,28 @@
++/* mkdir with error checking.
++   Copyright (C) 2017 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 <support/check.h>
++#include <support/xunistd.h>
++#include <sys/stat.h>
++
++void
++xmkdir (const char *path, mode_t mode)
++{
++  if (mkdir (path, mode) != 0)
++    FAIL_EXIT1 ("mkdir (\"%s\", 0%o): %m", path, mode);
++}
+diff --git a/support/xmmap.c b/support/xmmap.c
+new file mode 100644
+index 0000000000..435b1eb733
+--- /dev/null
++++ b/support/xmmap.c
+@@ -0,0 +1,31 @@
++/* mmap with error checking.
++   Copyright (C) 2016-2017 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 <support/check.h>
++#include <support/xunistd.h>
++#include <sys/mman.h>
++
++void *
++xmmap (void *addr, size_t length, int prot, int flags, int fd)
++{
++  void *result = mmap (addr, length, prot, flags, fd, 0);
++  if (result == MAP_FAILED)
++    FAIL_EXIT1 ("mmap of %zu bytes, prot=0x%x, flags=0x%x: %m",
++                length, prot, flags);
++  return result;
++}
+diff --git a/support/xmunmap.c b/support/xmunmap.c
+new file mode 100644
+index 0000000000..6ef5a4a468
+--- /dev/null
++++ b/support/xmunmap.c
+@@ -0,0 +1,28 @@
++/* munmap with error checking.
++   Copyright (C) 2016-2017 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 <support/check.h>
++#include <support/xunistd.h>
++#include <sys/mman.h>
++
++void
++xmunmap (void *addr, size_t length)
++{
++  if (munmap (addr, length) != 0)
++    FAIL_EXIT1 ("munmap of %zu bytes: %m", length);
++}
+diff --git a/support/xopen.c b/support/xopen.c
+new file mode 100644
+index 0000000000..7f033a03a7
+--- /dev/null
++++ b/support/xopen.c
+@@ -0,0 +1,30 @@
++/* open64 with error checking.
++   Copyright (C) 2017 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 <support/check.h>
++#include <support/xunistd.h>
++#include <fcntl.h>
++
++int
++xopen (const char *path, int flags, mode_t mode)
++{
++  int ret = open64 (path, flags, mode);
++  if (ret < 0)
++    FAIL_EXIT1 ("open64 (\"%s\", 0x%x, 0%o): %m", path, flags, mode);
++  return ret;
++}
+diff --git a/support/xpipe.c b/support/xpipe.c
+new file mode 100644
+index 0000000000..89a64a55c1
+--- /dev/null
++++ b/support/xpipe.c
+@@ -0,0 +1,28 @@
++/* pipe with error checking.
++   Copyright (C) 2017 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 <support/xunistd.h>
++
++#include <support/check.h>
++
++void
++xpipe (int fds[2])
++{
++  if (pipe (fds) < 0)
++    FAIL_EXIT1 ("pipe: %m");
++}
+diff --git a/support/xpoll.c b/support/xpoll.c
+new file mode 100644
+index 0000000000..bec2521ffc
+--- /dev/null
++++ b/support/xpoll.c
+@@ -0,0 +1,32 @@
++/* poll with error checking.
++   Copyright (C) 2016-2017 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 <support/xsocket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++int
++xpoll (struct pollfd *fds, nfds_t nfds, int timeout)
++{
++  int ret = poll (fds, nfds, timeout);
++  if (ret < 0)
++    FAIL_EXIT1 ("poll: %m");
++  return ret;
++}
+diff --git a/support/xpthread_attr_destroy.c b/support/xpthread_attr_destroy.c
+new file mode 100644
+index 0000000000..664c809e9f
+--- /dev/null
++++ b/support/xpthread_attr_destroy.c
+@@ -0,0 +1,26 @@
++/* pthread_attr_destroy with error checking.
++   Copyright (C) 2017 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 <support/xthread.h>
++
++void
++xpthread_attr_destroy (pthread_attr_t *attr)
++{
++  xpthread_check_return ("pthread_attr_destroy",
++			 pthread_attr_destroy (attr));
++}
+diff --git a/support/xpthread_attr_init.c b/support/xpthread_attr_init.c
+new file mode 100644
+index 0000000000..2e30ade9ab
+--- /dev/null
++++ b/support/xpthread_attr_init.c
+@@ -0,0 +1,25 @@
++/* pthread_attr_init with error checking.
++   Copyright (C) 2017 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 <support/xthread.h>
++
++void
++xpthread_attr_init (pthread_attr_t *attr)
++{
++  xpthread_check_return ("pthread_attr_init", pthread_attr_init (attr));
++}
+diff --git a/support/xpthread_attr_setdetachstate.c b/support/xpthread_attr_setdetachstate.c
+new file mode 100644
+index 0000000000..b544dbaa42
+--- /dev/null
++++ b/support/xpthread_attr_setdetachstate.c
+@@ -0,0 +1,27 @@
++/* pthread_attr_setdetachstate with error checking.
++   Copyright (C) 2017 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 <support/xthread.h>
++
++void
++xpthread_attr_setdetachstate (pthread_attr_t *attr, int detachstate)
++{
++  xpthread_check_return ("pthread_attr_setdetachstate",
++			 pthread_attr_setdetachstate (attr,
++						      detachstate));
++}
+diff --git a/support/xpthread_attr_setstacksize.c b/support/xpthread_attr_setstacksize.c
+new file mode 100644
+index 0000000000..02d06310a9
+--- /dev/null
++++ b/support/xpthread_attr_setstacksize.c
+@@ -0,0 +1,26 @@
++/* pthread_attr_setstacksize with error checking.
++   Copyright (C) 2017 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 <support/xthread.h>
++
++void
++xpthread_attr_setstacksize (pthread_attr_t *attr, size_t stacksize)
++{
++  xpthread_check_return ("pthread_attr_setstacksize",
++			 pthread_attr_setstacksize (attr, stacksize));
++}
+diff --git a/support/xpthread_barrier_destroy.c b/support/xpthread_barrier_destroy.c
+new file mode 100644
+index 0000000000..efc0719a63
+--- /dev/null
++++ b/support/xpthread_barrier_destroy.c
+@@ -0,0 +1,26 @@
++/* pthread_barrier_destroy with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_barrier_destroy (pthread_barrier_t *barrier)
++{
++  xpthread_check_return ("pthread_barrier_destroy",
++                         pthread_barrier_destroy (barrier));
++}
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdim-vis3.S b/support/xpthread_barrier_init.c
+similarity index 65%
+rename from sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdim-vis3.S
+rename to support/xpthread_barrier_init.c
+index 4a479b1a59..b32dad1315 100644
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdim-vis3.S
++++ b/support/xpthread_barrier_init.c
+@@ -1,7 +1,6 @@
+-/* Compute positive difference, sparc 32-bit+v9+vis3.
+-   Copyright (C) 2013-2016 Free Software Foundation, Inc.
++/* pthread_barrier_init with error checking.
++   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by David S. Miller <davem@davemloft.net>.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -17,18 +16,12 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-#include <sysdep.h>
++#include <support/xthread.h>
+ 
+-ENTRY(__fdim_vis3)
+-	movwtos	%o0, %f0
+-	movwtos	%o1, %f1
+-	movwtos	%o2, %f2
+-	movwtos	%o3, %f3
+-	fcmpd	%f0, %f2
+-	fbug	1f
+-	 nop
+-	fzero	%f0
+-	fnegd	%f0, %f2
+-1:	retl
+-	 fsubd	%f0, %f2, %f0
+-END(__fdim_vis3)
++void
++xpthread_barrier_init (pthread_barrier_t *barrier,
++                       pthread_barrierattr_t *attr, unsigned int count)
++{
++  xpthread_check_return ("pthread_barrier_init",
++                         pthread_barrier_init (barrier, attr, count));
++}
+diff --git a/support/xpthread_barrier_wait.c b/support/xpthread_barrier_wait.c
+new file mode 100644
+index 0000000000..7cee44d0a3
+--- /dev/null
++++ b/support/xpthread_barrier_wait.c
+@@ -0,0 +1,28 @@
++/* pthread_barrier_wait with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++int
++xpthread_barrier_wait (pthread_barrier_t *barrier)
++{
++  int ret = pthread_barrier_wait (barrier);
++  if (ret != 0 && ret != PTHREAD_BARRIER_SERIAL_THREAD)
++    xpthread_check_return ("pthread_barrier_wait", ret);
++  return ret == PTHREAD_BARRIER_SERIAL_THREAD;
++}
+diff --git a/support/xpthread_cancel.c b/support/xpthread_cancel.c
+new file mode 100644
+index 0000000000..3af16f9b54
+--- /dev/null
++++ b/support/xpthread_cancel.c
+@@ -0,0 +1,25 @@
++/* pthread_cancel with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_cancel (pthread_t thr)
++{
++  xpthread_check_return ("pthread_cancel", pthread_cancel (thr));
++}
+diff --git a/support/xpthread_check_return.c b/support/xpthread_check_return.c
+new file mode 100644
+index 0000000000..3094d82e9c
+--- /dev/null
++++ b/support/xpthread_check_return.c
+@@ -0,0 +1,34 @@
++/* Return value checking for pthread functions, exit variant.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++#include <errno.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++void
++xpthread_check_return (const char *function, int value)
++{
++  if (value != 0)
++    {
++      errno = value;
++      FAIL_EXIT1 ("%s: %m", function);
++    }
++}
+diff --git a/support/xpthread_cond_wait.c b/support/xpthread_cond_wait.c
+new file mode 100644
+index 0000000000..b0e9b2a232
+--- /dev/null
++++ b/support/xpthread_cond_wait.c
+@@ -0,0 +1,26 @@
++/* pthread_cond_wait with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex)
++{
++  xpthread_check_return
++    ("pthread_cond_wait", pthread_cond_wait (cond, mutex));
++}
+diff --git a/support/xpthread_create.c b/support/xpthread_create.c
+new file mode 100644
+index 0000000000..98c63e54c3
+--- /dev/null
++++ b/support/xpthread_create.c
+@@ -0,0 +1,29 @@
++/* pthread_create with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++pthread_t
++xpthread_create (pthread_attr_t *attr,
++                 void *(*thread_func) (void *), void *closure)
++{
++  pthread_t thr;
++  xpthread_check_return
++    ("pthread_create", pthread_create (&thr, attr, thread_func, closure));
++  return thr;
++}
+diff --git a/support/xpthread_detach.c b/support/xpthread_detach.c
+new file mode 100644
+index 0000000000..2088af2f57
+--- /dev/null
++++ b/support/xpthread_detach.c
+@@ -0,0 +1,25 @@
++/* pthread_detach with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_detach (pthread_t thr)
++{
++  xpthread_check_return ("pthread_detach", pthread_detach (thr));
++}
+diff --git a/support/xpthread_join.c b/support/xpthread_join.c
+new file mode 100644
+index 0000000000..f23bb9a5ae
+--- /dev/null
++++ b/support/xpthread_join.c
+@@ -0,0 +1,27 @@
++/* pthread_join with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void *
++xpthread_join (pthread_t thr)
++{
++  void *result;
++  xpthread_check_return ("pthread_join", pthread_join (thr, &result));
++  return result;
++}
+diff --git a/support/xpthread_mutex_consistent.c b/support/xpthread_mutex_consistent.c
+new file mode 100644
+index 0000000000..52364be365
+--- /dev/null
++++ b/support/xpthread_mutex_consistent.c
+@@ -0,0 +1,26 @@
++/* pthread_mutex_consistent with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_mutex_consistent (pthread_mutex_t *mutex)
++{
++  xpthread_check_return ("pthread_mutex_consistent",
++                         pthread_mutex_consistent (mutex));
++}
+diff --git a/support/xpthread_mutex_destroy.c b/support/xpthread_mutex_destroy.c
+new file mode 100644
+index 0000000000..f11f8f0acd
+--- /dev/null
++++ b/support/xpthread_mutex_destroy.c
+@@ -0,0 +1,26 @@
++/* pthread_mutex_destroy with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_mutex_destroy (pthread_mutex_t *mutex)
++{
++  xpthread_check_return ("pthread_mutex_destroy",
++                         pthread_mutex_destroy (mutex));
++}
+diff --git a/support/xpthread_mutex_init.c b/support/xpthread_mutex_init.c
+new file mode 100644
+index 0000000000..2d16d1b9d9
+--- /dev/null
++++ b/support/xpthread_mutex_init.c
+@@ -0,0 +1,26 @@
++/* pthread_mutex_init with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_mutex_init (pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
++{
++  xpthread_check_return ("pthread_mutex_init",
++                         pthread_mutex_init (mutex, attr));
++}
+diff --git a/support/xpthread_mutex_lock.c b/support/xpthread_mutex_lock.c
+new file mode 100644
+index 0000000000..af727b45f3
+--- /dev/null
++++ b/support/xpthread_mutex_lock.c
+@@ -0,0 +1,25 @@
++/* pthread_mutex_lock with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_mutex_lock (pthread_mutex_t *mutex)
++{
++  xpthread_check_return ("pthread_mutex_lock", pthread_mutex_lock (mutex));
++}
+diff --git a/support/xpthread_mutex_unlock.c b/support/xpthread_mutex_unlock.c
+new file mode 100644
+index 0000000000..161b41edf6
+--- /dev/null
++++ b/support/xpthread_mutex_unlock.c
+@@ -0,0 +1,25 @@
++/* pthread_mutex_unlock with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_mutex_unlock (pthread_mutex_t *mutex)
++{
++  xpthread_check_return ("pthread_mutex_unlock", pthread_mutex_unlock (mutex));
++}
+diff --git a/support/xpthread_mutexattr_destroy.c b/support/xpthread_mutexattr_destroy.c
+new file mode 100644
+index 0000000000..c699e32b41
+--- /dev/null
++++ b/support/xpthread_mutexattr_destroy.c
+@@ -0,0 +1,26 @@
++/* pthread_mutexattr_destroy with error checking.
++   Copyright (C) 2017 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 <support/xthread.h>
++
++void
++xpthread_mutexattr_destroy (pthread_mutexattr_t *attr)
++{
++  xpthread_check_return ("pthread_mutexattr_destroy",
++                         pthread_mutexattr_destroy (attr));
++}
+diff --git a/support/xpthread_mutexattr_init.c b/support/xpthread_mutexattr_init.c
+new file mode 100644
+index 0000000000..fa93fab178
+--- /dev/null
++++ b/support/xpthread_mutexattr_init.c
+@@ -0,0 +1,25 @@
++/* pthread_mutexattr_init with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_mutexattr_init (pthread_mutexattr_t *attr)
++{
++  xpthread_check_return ("pthread_mutexattr_init", pthread_mutexattr_init (attr));
++}
+diff --git a/sysdeps/sparc/sparc64/fpu/s_fdim.S b/support/xpthread_mutexattr_setprotocol.c
+similarity index 67%
+rename from sysdeps/sparc/sparc64/fpu/s_fdim.S
+rename to support/xpthread_mutexattr_setprotocol.c
+index 7fae72a251..353f75e3d7 100644
+--- a/sysdeps/sparc/sparc64/fpu/s_fdim.S
++++ b/support/xpthread_mutexattr_setprotocol.c
+@@ -1,7 +1,6 @@
+-/* Compute positive difference, sparc 64-bit.
+-   Copyright (C) 2013-2016 Free Software Foundation, Inc.
++/* pthread_mutexattr_setprotocol with error checking.
++   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by David S. Miller <davem@davemloft.net>.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -17,16 +16,11 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-#include <sysdep.h>
+-#include <math_ldbl_opt.h>
++#include <support/xthread.h>
+ 
+-ENTRY(__fdim)
+-	fcmpd	%f0, %f2
+-	fbug	1f
+-	 nop
+-	fzero	%f0
+-	fnegd	%f0, %f2
+-1:	retl
+-	 fsubd	%f0, %f2, %f0
+-END(__fdim)
+-weak_alias (__fdim, fdim)
++void
++xpthread_mutexattr_setprotocol (pthread_mutexattr_t *attr, int flag)
++{
++  xpthread_check_return ("pthread_mutexattr_setprotocol",
++                         pthread_mutexattr_setprotocol (attr, flag));
++}
+diff --git a/support/xpthread_mutexattr_setpshared.c b/support/xpthread_mutexattr_setpshared.c
+new file mode 100644
+index 0000000000..242da1aeca
+--- /dev/null
++++ b/support/xpthread_mutexattr_setpshared.c
+@@ -0,0 +1,26 @@
++/* pthread_mutexattr_setpshared with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_mutexattr_setpshared (pthread_mutexattr_t *attr, int flag)
++{
++  xpthread_check_return ("pthread_mutexattr_setpshared",
++                         pthread_mutexattr_setpshared (attr, flag));
++}
+diff --git a/support/xpthread_mutexattr_setrobust.c b/support/xpthread_mutexattr_setrobust.c
+new file mode 100644
+index 0000000000..d7d6fa8630
+--- /dev/null
++++ b/support/xpthread_mutexattr_setrobust.c
+@@ -0,0 +1,26 @@
++/* pthread_mutexattr_setrobust with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_mutexattr_setrobust (pthread_mutexattr_t *attr, int flag)
++{
++  xpthread_check_return ("pthread_mutexattr_setrobust",
++                         pthread_mutexattr_setrobust (attr, flag));
++}
+diff --git a/support/xpthread_mutexattr_settype.c b/support/xpthread_mutexattr_settype.c
+new file mode 100644
+index 0000000000..cf22170b56
+--- /dev/null
++++ b/support/xpthread_mutexattr_settype.c
+@@ -0,0 +1,26 @@
++/* pthread_mutexattr_settype with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_mutexattr_settype (pthread_mutexattr_t *attr, int flag)
++{
++  xpthread_check_return ("pthread_mutexattr_settype",
++                         pthread_mutexattr_settype (attr, flag));
++}
+diff --git a/support/xpthread_once.c b/support/xpthread_once.c
+new file mode 100644
+index 0000000000..70d58dbab2
+--- /dev/null
++++ b/support/xpthread_once.c
+@@ -0,0 +1,25 @@
++/* pthread_once with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_once (pthread_once_t *guard, void (*func) (void))
++{
++  xpthread_check_return ("pthread_once", pthread_once (guard, func));
++}
+diff --git a/support/xpthread_sigmask.c b/support/xpthread_sigmask.c
+new file mode 100644
+index 0000000000..0ba9ca02dc
+--- /dev/null
++++ b/support/xpthread_sigmask.c
+@@ -0,0 +1,34 @@
++/* pthread_sigmask with error checking.
++   Copyright (C) 2016-2017 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 <support/xsignal.h>
++#include <support/support.h>
++
++#include <unistd.h>
++
++void
++xpthread_sigmask (int how, const sigset_t *set, sigset_t *oldset)
++{
++  if (pthread_sigmask (how, set, oldset) != 0)
++    {
++      write_message ("error: pthread_setmask failed\n");
++      /* Do not use exit because pthread_sigmask can be called from a
++         signal handler.  */
++      _exit (1);
++    }
++}
+diff --git a/support/xpthread_spin_lock.c b/support/xpthread_spin_lock.c
+new file mode 100644
+index 0000000000..6975215b17
+--- /dev/null
++++ b/support/xpthread_spin_lock.c
+@@ -0,0 +1,25 @@
++/* pthread_spin_lock with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_spin_lock (pthread_spinlock_t *lock)
++{
++  xpthread_check_return ("pthread_spin_lock", pthread_spin_lock (lock));
++}
+diff --git a/support/xpthread_spin_unlock.c b/support/xpthread_spin_unlock.c
+new file mode 100644
+index 0000000000..4f19a44c48
+--- /dev/null
++++ b/support/xpthread_spin_unlock.c
+@@ -0,0 +1,25 @@
++/* pthread_spin_unlock with error checking.
++   Copyright (C) 2016-2017 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 <support/xthread.h>
++
++void
++xpthread_spin_unlock (pthread_spinlock_t *lock)
++{
++  xpthread_check_return ("pthread_spin_unlock", pthread_spin_unlock (lock));
++}
+diff --git a/support/xrealloc.c b/support/xrealloc.c
+new file mode 100644
+index 0000000000..00c313880c
+--- /dev/null
++++ b/support/xrealloc.c
+@@ -0,0 +1,32 @@
++/* Error-checking wrapper for realloc.
++   Copyright (C) 2016-2017 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 <support/support.h>
++
++#include <stdarg.h>
++#include <stdio.h>
++#include <stdlib.h>
++
++void *
++xrealloc (void *p, size_t n)
++{
++  void *result = realloc (p, n);
++  if (result == NULL && (n > 0 || p == NULL))
++    oom_error ("realloc", n);
++  return result;
++}
+diff --git a/support/xrecvfrom.c b/support/xrecvfrom.c
+new file mode 100644
+index 0000000000..17809c4dd2
+--- /dev/null
++++ b/support/xrecvfrom.c
+@@ -0,0 +1,33 @@
++/* recvfrom with error checking.
++   Copyright (C) 2016-2017 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 <support/xsocket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++size_t
++xrecvfrom (int fd, void *buf, size_t buflen, int flags,
++           struct sockaddr *sa, socklen_t *salen)
++{
++  ssize_t ret = recvfrom (fd, buf, buflen, flags, sa, salen);
++  if (ret < 0)
++    FAIL_EXIT1 ("error: recvfrom (%d), %zu bytes buffer: %m", fd, buflen);
++  return ret;
++}
+diff --git a/support/xsendto.c b/support/xsendto.c
+new file mode 100644
+index 0000000000..20bddf6965
+--- /dev/null
++++ b/support/xsendto.c
+@@ -0,0 +1,35 @@
++/* sendto with error checking.
++   Copyright (C) 2016-2017 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 <support/xsocket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++void
++xsendto (int fd, const void *buf, size_t buflen, int flags,
++         const struct sockaddr *sa, socklen_t salen)
++{
++  ssize_t ret = sendto (fd, buf, buflen, flags, sa, salen);
++  if (ret < 0)
++    FAIL_EXIT1 ("sendto (%d), %zu bytes, family %d: %m",
++                fd, buflen, sa->sa_family);
++  if (ret != buflen)
++    FAIL_EXIT1 ("sendto (%d) sent %zd bytes instead of %zu", fd, ret, buflen);
++}
+diff --git a/sysdeps/sparc/sparc32/fpu/s_fdimf.S b/support/xsetsockopt.c
+similarity index 62%
+rename from sysdeps/sparc/sparc32/fpu/s_fdimf.S
+rename to support/xsetsockopt.c
+index c3fe8afa98..9931882e75 100644
+--- a/sysdeps/sparc/sparc32/fpu/s_fdimf.S
++++ b/support/xsetsockopt.c
+@@ -1,7 +1,6 @@
+-/* Compute positive difference, sparc 32-bit.
+-   Copyright (C) 2013-2016 Free Software Foundation, Inc.
++/* setsockopt with error checking.
++   Copyright (C) 2016-2017 Free Software Foundation, Inc.
+    This file is part of the GNU C Library.
+-   Contributed by David S. Miller <davem@davemloft.net>.
+ 
+    The GNU C Library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+@@ -17,19 +16,16 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-#include <sysdep.h>
++#include <support/xsocket.h>
+ 
+-ENTRY(__fdimf)
+-	st	%o0, [%sp + 72]
+-	st	%o1, [%sp + 76]
+-	ld	[%sp + 72], %f0
+-	ld	[%sp + 76], %f1
+-	fcmps	%f0, %f1
+-	fbug	1f
+-	 st	%g0, [%sp + 72]
+-	ld	[%sp + 72], %f0
+-	fnegs	%f0, %f1
+-1:	retl
+-	 fsubs	%f0, %f1, %f0
+-END(__fdimf)
+-weak_alias (__fdimf, fdimf)
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++void
++xsetsockopt (int fd, int level, int name, const void *val, socklen_t vallen)
++{
++  if (setsockopt (fd, level, name, val, vallen) != 0)
++    FAIL_EXIT1 ("setsockopt (%d, %d, %d), %zu bytes: %m",
++                fd, level, name, (size_t) vallen);
++}
+diff --git a/support/xsignal.h b/support/xsignal.h
+new file mode 100644
+index 0000000000..3dc0d9d5ce
+--- /dev/null
++++ b/support/xsignal.h
+@@ -0,0 +1,34 @@
++/* Support functionality for using signals.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_SIGNAL_H
++#define SUPPORT_SIGNAL_H
++
++#include <signal.h>
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++/* The following functions call the corresponding libpthread functions
++   and terminate the process on error.  */
++
++void xpthread_sigmask (int how, const sigset_t *set, sigset_t *oldset);
++
++__END_DECLS
++
++#endif /* SUPPORT_SIGNAL_H */
+diff --git a/support/xsocket.c b/support/xsocket.c
+new file mode 100644
+index 0000000000..c1deaee924
+--- /dev/null
++++ b/support/xsocket.c
+@@ -0,0 +1,32 @@
++/* socket with error checking.
++   Copyright (C) 2016-2017 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 <support/xsocket.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++
++int
++xsocket (int domain, int type, int protocol)
++{
++  int fd = socket (domain, type, protocol);
++  if (fd < 0)
++    FAIL_EXIT1 ("socket (%d, %d, %d): %m\n", domain, type, protocol);
++  return fd;
++}
+diff --git a/support/xsocket.h b/support/xsocket.h
+new file mode 100644
+index 0000000000..d6724948d8
+--- /dev/null
++++ b/support/xsocket.h
+@@ -0,0 +1,39 @@
++/* Error-checking wrappers for socket functions.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_XSOCKET_H
++#define SUPPORT_XSOCKET_H
++
++#include <poll.h>
++#include <sys/socket.h>
++#include <sys/types.h>
++
++int xsocket (int, int, int);
++void xsetsockopt (int, int, int, const void *, socklen_t);
++void xgetsockname (int, struct sockaddr *, socklen_t *);
++void xconnect (int, const struct sockaddr *, socklen_t);
++void xbind (int, const struct sockaddr *, socklen_t);
++void xlisten (int, int);
++int xaccept (int, struct sockaddr *, socklen_t *);
++int xaccept4 (int, struct sockaddr *, socklen_t *, int);
++void xsendto (int, const void *, size_t, int,
++              const struct sockaddr *, socklen_t);
++size_t xrecvfrom (int, void *, size_t, int, struct sockaddr *, socklen_t *);
++int xpoll (struct pollfd *, nfds_t, int);
++
++#endif /* SUPPORT_XSOCKET_H */
+diff --git a/support/xstdio.h b/support/xstdio.h
+new file mode 100644
+index 0000000000..bcc2e863bf
+--- /dev/null
++++ b/support/xstdio.h
+@@ -0,0 +1,32 @@
++/* Error-checking wrappers for stdio functions.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_XSTDIO_H
++#define SUPPORT_XSTDIO_H
++
++#include <stdio.h>
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++FILE *xfopen (const char *path, const char *mode);
++void xfclose (FILE *);
++
++__END_DECLS
++
++#endif /* SUPPORT_XSTDIO_H */
+diff --git a/support/xstrdup.c b/support/xstrdup.c
+new file mode 100644
+index 0000000000..d6a8c04baf
+--- /dev/null
++++ b/support/xstrdup.c
+@@ -0,0 +1,30 @@
++/* strdup with error checking.
++   Copyright (C) 2016-2017 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 <support/support.h>
++
++#include <string.h>
++
++char *
++xstrdup (const char *s)
++{
++  char *p = strdup (s);
++  if (p == NULL)
++    oom_error ("strdup", strlen (s));
++  return p;
++}
+diff --git a/support/xthread.h b/support/xthread.h
+new file mode 100644
+index 0000000000..6dd7e709be
+--- /dev/null
++++ b/support/xthread.h
+@@ -0,0 +1,77 @@
++/* Support functionality for using threads.
++   Copyright (C) 2016-2017 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/>.  */
++
++#ifndef SUPPORT_THREAD_H
++#define SUPPORT_THREAD_H
++
++#include <pthread.h>
++#include <sys/cdefs.h>
++
++__BEGIN_DECLS
++
++/* Terminate the process (with exit status 0) after SECONDS have
++   elapsed, from a helper thread.  The process is terminated with the
++   exit function, so atexit handlers are executed.  */
++void delayed_exit (int seconds);
++
++/* Terminate the process (with exit status 1) if VALUE is not zero.
++   In that case, print a failure message to standard output mentioning
++   FUNCTION.  The process is terminated with the exit function, so
++   atexit handlers are executed.  */
++void xpthread_check_return (const char *function, int value);
++
++/* The following functions call the corresponding libpthread functions
++   and terminate the process on error.  */
++
++void xpthread_barrier_init (pthread_barrier_t *barrier,
++                            pthread_barrierattr_t *attr, unsigned int count);
++void xpthread_barrier_destroy (pthread_barrier_t *barrier);
++void xpthread_mutexattr_destroy (pthread_mutexattr_t *);
++void xpthread_mutexattr_init (pthread_mutexattr_t *);
++void xpthread_mutexattr_setprotocol (pthread_mutexattr_t *, int);
++void xpthread_mutexattr_setpshared (pthread_mutexattr_t *, int);
++void xpthread_mutexattr_setrobust (pthread_mutexattr_t *, int);
++void xpthread_mutexattr_settype (pthread_mutexattr_t *, int);
++void xpthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *);
++void xpthread_mutex_destroy (pthread_mutex_t *);
++void xpthread_mutex_lock (pthread_mutex_t *mutex);
++void xpthread_mutex_unlock (pthread_mutex_t *mutex);
++void xpthread_mutex_consistent (pthread_mutex_t *);
++void xpthread_spin_lock (pthread_spinlock_t *lock);
++void xpthread_spin_unlock (pthread_spinlock_t *lock);
++void xpthread_cond_wait (pthread_cond_t * cond, pthread_mutex_t * mutex);
++pthread_t xpthread_create (pthread_attr_t *attr,
++                           void *(*thread_func) (void *), void *closure);
++void xpthread_detach (pthread_t thr);
++void xpthread_cancel (pthread_t thr);
++void *xpthread_join (pthread_t thr);
++void xpthread_once (pthread_once_t *guard, void (*func) (void));
++void xpthread_attr_destroy (pthread_attr_t *attr);
++void xpthread_attr_init (pthread_attr_t *attr);
++void xpthread_attr_setdetachstate (pthread_attr_t *attr,
++				   int detachstate);
++void xpthread_attr_setstacksize (pthread_attr_t *attr,
++				 size_t stacksize);
++
++/* This function returns non-zero if pthread_barrier_wait returned
++   PTHREAD_BARRIER_SERIAL_THREAD.  */
++int xpthread_barrier_wait (pthread_barrier_t *barrier);
++
++__END_DECLS
++
++#endif /* SUPPORT_THREAD_H */
+diff --git a/support/xunistd.h b/support/xunistd.h
+new file mode 100644
+index 0000000000..151d743e1f
+--- /dev/null
++++ b/support/xunistd.h
+@@ -0,0 +1,56 @@
++/* POSIX-specific extra functions.
++   Copyright (C) 2016-2017 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 wrapper functions use POSIX types and therefore cannot be
++   declared in <support/support.h>.  */
++
++#ifndef SUPPORT_XUNISTD_H
++#define SUPPORT_XUNISTD_H
++
++#include <sys/cdefs.h>
++#include <sys/types.h>
++#include <unistd.h>
++
++__BEGIN_DECLS
++
++struct stat64;
++
++pid_t xfork (void);
++pid_t xwaitpid (pid_t, int *status, int flags);
++void xpipe (int[2]);
++void xdup2 (int, int);
++int xopen (const char *path, int flags, mode_t);
++void xstat (const char *path, struct stat64 *);
++void xmkdir (const char *path, mode_t);
++void xchroot (const char *path);
++
++/* Close the file descriptor.  Ignore EINTR errors, but terminate the
++   process on other errors.  */
++void xclose (int);
++
++/* Write the buffer.  Retry on short writes.  */
++void xwrite (int, const void *, size_t);
++
++/* Invoke mmap with a zero file offset.  */
++void *xmmap (void *addr, size_t length, int prot, int flags, int fd);
++
++void xmunmap (void *addr, size_t length);
++
++__END_DECLS
++
++#endif /* SUPPORT_XUNISTD_H */
+diff --git a/support/xwaitpid.c b/support/xwaitpid.c
+new file mode 100644
+index 0000000000..204795e4c0
+--- /dev/null
++++ b/support/xwaitpid.c
+@@ -0,0 +1,33 @@
++/* waitpid with error checking.
++   Copyright (C) 2016-2017 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 <support/xunistd.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <support/check.h>
++#include <sys/wait.h>
++
++int
++xwaitpid (int pid, int *status, int flags)
++{
++  pid_t result = waitpid (pid, status, flags);
++  if (result < 0)
++    FAIL_EXIT1 ("waitpid: %m\n");
++  return result;
++}
+diff --git a/support/xwrite.c b/support/xwrite.c
+new file mode 100644
+index 0000000000..134e8ee4c1
+--- /dev/null
++++ b/support/xwrite.c
+@@ -0,0 +1,39 @@
++/* write with error checking and retries.
++   Copyright (C) 2016-2017 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 <support/xunistd.h>
++
++#include <support/check.h>
++
++void
++xwrite (int fd, const void *buffer, size_t length)
++{
++  const char *p = buffer;
++  const char *end = p + length;
++  while (p < end)
++    {
++      ssize_t ret = write (fd, p, end - p);
++      if (ret < 0)
++        FAIL_EXIT1 ("write of %zu bytes failed after %td: %m",
++                    length, p - (const char *) buffer);
++      if (ret == 0)
++        FAIL_EXIT1 ("write return 0 after writing %td bytes of %zu",
++                    p - (const char *) buffer, length);
++      p += ret;
++    }
++}
+diff --git a/sysdeps/aarch64/dl-machine.h b/sysdeps/aarch64/dl-machine.h
+index 282805e396..e86d8b5b63 100644
+--- a/sysdeps/aarch64/dl-machine.h
++++ b/sysdeps/aarch64/dl-machine.h
+@@ -172,8 +172,8 @@ _dl_start_user:							\n\
+ 	cmp	x0, #0						\n\
+ 	bne	1b						\n\
+ 	// Update _dl_argv					\n\
+-	adrp	x3, _dl_argv					\n\
+-	str	x2, [x3, #:lo12:_dl_argv]			\n\
++	adrp	x3, __GI__dl_argv				\n\
++	str	x2, [x3, #:lo12:__GI__dl_argv]			\n\
+ .L_done_stack_adjust:						\n\
+ 	// compute envp						\n\
+ 	add	x3, x2, x1, lsl #3				\n\
+diff --git a/sysdeps/aarch64/nptl/tcb-offsets.sym b/sysdeps/aarch64/nptl/tcb-offsets.sym
+index 0677aeabff..238647dd47 100644
+--- a/sysdeps/aarch64/nptl/tcb-offsets.sym
++++ b/sysdeps/aarch64/nptl/tcb-offsets.sym
+@@ -2,6 +2,5 @@
+ #include <tls.h>
+ 
+ PTHREAD_MULTIPLE_THREADS_OFFSET		offsetof (struct pthread, header.multiple_threads)
+-PTHREAD_PID_OFFSET			offsetof (struct pthread, pid)
+ PTHREAD_TID_OFFSET			offsetof (struct pthread, tid)
+ PTHREAD_SIZEOF				sizeof (struct pthread)
+diff --git a/sysdeps/alpha/fpu/s_ceil.c b/sysdeps/alpha/fpu/s_ceil.c
+index c1ff864d4b..e9c350af1c 100644
+--- a/sysdeps/alpha/fpu/s_ceil.c
++++ b/sysdeps/alpha/fpu/s_ceil.c
+@@ -26,17 +26,16 @@
+ double
+ __ceil (double x)
+ {
++  if (isnan (x))
++    return x + x;
++
+   if (isless (fabs (x), 9007199254740992.0))	/* 1 << DBL_MANT_DIG */
+     {
+       double tmp1, new_x;
+ 
+       new_x = -x;
+       __asm (
+-#ifdef _IEEE_FP_INEXACT
+-	     "cvttq/svim %2,%1\n\t"
+-#else
+ 	     "cvttq/svm %2,%1\n\t"
+-#endif
+ 	     "cvtqt/m %1,%0\n\t"
+ 	     : "=f"(new_x), "=&f"(tmp1)
+ 	     : "f"(new_x));
+diff --git a/sysdeps/alpha/fpu/s_ceilf.c b/sysdeps/alpha/fpu/s_ceilf.c
+index 7e63a6fe94..77e01a99f7 100644
+--- a/sysdeps/alpha/fpu/s_ceilf.c
++++ b/sysdeps/alpha/fpu/s_ceilf.c
+@@ -25,6 +25,9 @@
+ float
+ __ceilf (float x)
+ {
++  if (isnanf (x))
++    return x + x;
++
+   if (isless (fabsf (x), 16777216.0f))	/* 1 << FLT_MANT_DIG */
+     {
+       /* Note that Alpha S_Floating is stored in registers in a
+@@ -36,11 +39,7 @@ __ceilf (float x)
+ 
+       new_x = -x;
+       __asm ("cvtst/s %3,%2\n\t"
+-#ifdef _IEEE_FP_INEXACT
+-	     "cvttq/svim %2,%1\n\t"
+-#else
+ 	     "cvttq/svm %2,%1\n\t"
+-#endif
+ 	     "cvtqt/m %1,%0\n\t"
+ 	     : "=f"(new_x), "=&f"(tmp1), "=&f"(tmp2)
+ 	     : "f"(new_x));
+diff --git a/sysdeps/alpha/fpu/s_floor.c b/sysdeps/alpha/fpu/s_floor.c
+index 1a6f8c4617..9930f6be42 100644
+--- a/sysdeps/alpha/fpu/s_floor.c
++++ b/sysdeps/alpha/fpu/s_floor.c
+@@ -27,16 +27,15 @@
+ double
+ __floor (double x)
+ {
++  if (isnan (x))
++    return x + x;
++
+   if (isless (fabs (x), 9007199254740992.0))	/* 1 << DBL_MANT_DIG */
+     {
+       double tmp1, new_x;
+ 
+       __asm (
+-#ifdef _IEEE_FP_INEXACT
+-	     "cvttq/svim %2,%1\n\t"
+-#else
+ 	     "cvttq/svm %2,%1\n\t"
+-#endif
+ 	     "cvtqt/m %1,%0\n\t"
+ 	     : "=f"(new_x), "=&f"(tmp1)
+ 	     : "f"(x));
+diff --git a/sysdeps/alpha/fpu/s_floorf.c b/sysdeps/alpha/fpu/s_floorf.c
+index 8cd80e2b42..015c04f40d 100644
+--- a/sysdeps/alpha/fpu/s_floorf.c
++++ b/sysdeps/alpha/fpu/s_floorf.c
+@@ -26,6 +26,9 @@
+ float
+ __floorf (float x)
+ {
++  if (isnanf (x))
++    return x + x;
++
+   if (isless (fabsf (x), 16777216.0f))	/* 1 << FLT_MANT_DIG */
+     {
+       /* Note that Alpha S_Floating is stored in registers in a
+@@ -36,11 +39,7 @@ __floorf (float x)
+       float tmp1, tmp2, new_x;
+ 
+       __asm ("cvtst/s %3,%2\n\t"
+-#ifdef _IEEE_FP_INEXACT
+-	     "cvttq/svim %2,%1\n\t"
+-#else
+ 	     "cvttq/svm %2,%1\n\t"
+-#endif
+ 	     "cvtqt/m %1,%0\n\t"
+ 	     : "=f"(new_x), "=&f"(tmp1), "=&f"(tmp2)
+ 	     : "f"(x));
+diff --git a/sysdeps/alpha/fpu/s_rint.c b/sysdeps/alpha/fpu/s_rint.c
+index f33fe72c11..259348afc0 100644
+--- a/sysdeps/alpha/fpu/s_rint.c
++++ b/sysdeps/alpha/fpu/s_rint.c
+@@ -23,6 +23,9 @@
+ double
+ __rint (double x)
+ {
++  if (isnan (x))
++    return x + x;
++
+   if (isless (fabs (x), 9007199254740992.0))	/* 1 << DBL_MANT_DIG */
+     {
+       double tmp1, new_x;
+diff --git a/sysdeps/alpha/fpu/s_rintf.c b/sysdeps/alpha/fpu/s_rintf.c
+index 1400dfe8d7..645728ad5b 100644
+--- a/sysdeps/alpha/fpu/s_rintf.c
++++ b/sysdeps/alpha/fpu/s_rintf.c
+@@ -22,6 +22,9 @@
+ float
+ __rintf (float x)
+ {
++  if (isnanf (x))
++    return x + x;
++
+   if (isless (fabsf (x), 16777216.0f))	/* 1 << FLT_MANT_DIG */
+     {
+       /* Note that Alpha S_Floating is stored in registers in a
+diff --git a/sysdeps/alpha/fpu/s_trunc.c b/sysdeps/alpha/fpu/s_trunc.c
+index 16cb114a72..4b986a6926 100644
+--- a/sysdeps/alpha/fpu/s_trunc.c
++++ b/sysdeps/alpha/fpu/s_trunc.c
+@@ -28,12 +28,11 @@ __trunc (double x)
+   double two52 = copysign (0x1.0p52, x);
+   double r, tmp;
+ 
++  if (isgreaterequal (fabs (x), 0x1.0p52))
++    return x;
++
+   __asm (
+-#ifdef _IEEE_FP_INEXACT
+-	 "addt/suic %2, %3, %1\n\tsubt/suic %1, %3, %0"
+-#else
+ 	 "addt/suc %2, %3, %1\n\tsubt/suc %1, %3, %0"
+-#endif
+ 	 : "=&f"(r), "=&f"(tmp)
+ 	 : "f"(x), "f"(two52));
+ 
+diff --git a/sysdeps/alpha/fpu/s_truncf.c b/sysdeps/alpha/fpu/s_truncf.c
+index 2290f28295..3e93356166 100644
+--- a/sysdeps/alpha/fpu/s_truncf.c
++++ b/sysdeps/alpha/fpu/s_truncf.c
+@@ -27,12 +27,11 @@ __truncf (float x)
+   float two23 = copysignf (0x1.0p23, x);
+   float r, tmp;
+ 
++  if (isgreaterequal (fabsf (x), 0x1.0p23))
++    return x;
++
+   __asm (
+-#ifdef _IEEE_FP_INEXACT
+-	 "adds/suic %2, %3, %1\n\tsubs/suic %1, %3, %0"
+-#else
+ 	 "adds/suc %2, %3, %1\n\tsubs/suc %1, %3, %0"
+-#endif
+ 	 : "=&f"(r), "=&f"(tmp)
+ 	 : "f"(x), "f"(two23));
+ 
+diff --git a/sysdeps/alpha/nptl/tcb-offsets.sym b/sysdeps/alpha/nptl/tcb-offsets.sym
+index c21a791040..1005621b37 100644
+--- a/sysdeps/alpha/nptl/tcb-offsets.sym
++++ b/sysdeps/alpha/nptl/tcb-offsets.sym
+@@ -10,5 +10,4 @@
+ #define thread_offsetof(mem)	(long)(offsetof(struct pthread, mem) - sizeof(struct pthread))
+ 
+ MULTIPLE_THREADS_OFFSET		thread_offsetof (header.multiple_threads)
+-PID_OFFSET			thread_offsetof (pid)
+ TID_OFFSET			thread_offsetof (tid)
+diff --git a/sysdeps/arm/nacl/libc.abilist b/sysdeps/arm/nacl/libc.abilist
+index 2f7751d167..dfa7198306 100644
+--- a/sysdeps/arm/nacl/libc.abilist
++++ b/sysdeps/arm/nacl/libc.abilist
+@@ -1840,4 +1840,5 @@ GLIBC_2.23 fts64_close F
+ GLIBC_2.23 fts64_open F
+ GLIBC_2.23 fts64_read F
+ GLIBC_2.23 fts64_set F
++GLIBC_2.24 GLIBC_2.24 A
+ GLIBC_2.24 quick_exit F
+diff --git a/sysdeps/arm/nptl/tcb-offsets.sym b/sysdeps/arm/nptl/tcb-offsets.sym
+index 92cc441d3d..bf9c0a1c17 100644
+--- a/sysdeps/arm/nptl/tcb-offsets.sym
++++ b/sysdeps/arm/nptl/tcb-offsets.sym
+@@ -7,5 +7,4 @@
+ #define thread_offsetof(mem)	(long)(offsetof(struct pthread, mem) - sizeof(struct pthread))
+ 
+ MULTIPLE_THREADS_OFFSET		thread_offsetof (header.multiple_threads)
+-PID_OFFSET			thread_offsetof (pid)
+ TID_OFFSET			thread_offsetof (tid)
+diff --git a/sysdeps/generic/unsecvars.h b/sysdeps/generic/unsecvars.h
+index d5b8119c9c..ac57bd5db0 100644
+--- a/sysdeps/generic/unsecvars.h
++++ b/sysdeps/generic/unsecvars.h
+@@ -4,11 +4,13 @@
+ #define UNSECURE_ENVVARS \
+   "GCONV_PATH\0"							      \
+   "GETCONF_DIR\0"							      \
++  "GLIBC_TUNABLES\0"							      \
+   "HOSTALIASES\0"							      \
+   "LD_AUDIT\0"								      \
+   "LD_DEBUG\0"								      \
+   "LD_DEBUG_OUTPUT\0"							      \
+   "LD_DYNAMIC_WEAK\0"							      \
++  "LD_HWCAP_MASK\0"							      \
+   "LD_LIBRARY_PATH\0"							      \
+   "LD_ORIGIN_PATH\0"							      \
+   "LD_PRELOAD\0"							      \
+diff --git a/sysdeps/gnu/glob64.c b/sysdeps/gnu/glob64.c
+index d1e4e6f0d5..52e97e2f6a 100644
+--- a/sysdeps/gnu/glob64.c
++++ b/sysdeps/gnu/glob64.c
+@@ -15,11 +15,8 @@
+ #undef __stat
+ #define __stat(file, buf) __xstat64 (_STAT_VER, file, buf)
+ 
+-#define NO_GLOB_PATTERN_P 1
+-
+ #define COMPILE_GLOB64	1
+ 
+ #include <posix/glob.c>
+ 
+ libc_hidden_def (glob64)
+-libc_hidden_def (globfree64)
+diff --git a/sysdeps/gnu/globfree64.c b/sysdeps/gnu/globfree64.c
+new file mode 100644
+index 0000000000..f092d0bf8b
+--- /dev/null
++++ b/sysdeps/gnu/globfree64.c
+@@ -0,0 +1,10 @@
++#include <dirent.h>
++#include <glob.h>
++#include <sys/stat.h>
++
++#define glob_t glob64_t
++#define globfree(pglob) globfree64 (pglob)
++
++#include <posix/globfree.c>
++
++libc_hidden_def (globfree64)
+diff --git a/sysdeps/hppa/dl-machine.h b/sysdeps/hppa/dl-machine.h
+index 9404211819..01bd5bf197 100644
+--- a/sysdeps/hppa/dl-machine.h
++++ b/sysdeps/hppa/dl-machine.h
+@@ -302,6 +302,10 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+ #define ARCH_LA_PLTENTER hppa_gnu_pltenter
+ #define ARCH_LA_PLTEXIT hppa_gnu_pltexit
+ 
++/* Adjust DL_STACK_END to get value we want in __libc_stack_end.  */
++#define DL_STACK_END(cookie) \
++  ((void *) (((long) (cookie)) + 0x160))
++
+ /* Initial entry point code for the dynamic linker.
+    The C function `_dl_start' is the real entry point;
+    its return value is the user program's entry point.  */
+@@ -401,11 +405,6 @@ asm (									\
+ 	/* Save the entry point in %r3. */				\
+ "	copy	%ret0,%r3\n"						\
+ 									\
+-	/* Remember the lowest stack address. */			\
+-"	addil	LT'__libc_stack_end,%r19\n"				\
+-"	ldw	RT'__libc_stack_end(%r1),%r20\n"			\
+-"	stw	%sp,0(%r20)\n"						\
+-									\
+ 	/* See if we were called as a command with the executable file	\
+ 	   name as an extra leading argument. */			\
+ "	addil	LT'_dl_skip_args,%r19\n"				\
+diff --git a/sysdeps/hppa/nptl/tcb-offsets.sym b/sysdeps/hppa/nptl/tcb-offsets.sym
+index c2f326ee3d..6e852f35b1 100644
+--- a/sysdeps/hppa/nptl/tcb-offsets.sym
++++ b/sysdeps/hppa/nptl/tcb-offsets.sym
+@@ -3,7 +3,6 @@
+ 
+ RESULT			offsetof (struct pthread, result)
+ TID			offsetof (struct pthread, tid)
+-PID			offsetof (struct pthread, pid)
+ CANCELHANDLING		offsetof (struct pthread, cancelhandling)
+ CLEANUP_JMP_BUF		offsetof (struct pthread, cleanup_jmp_buf)
+ MULTIPLE_THREADS_OFFSET	offsetof (struct pthread, header.multiple_threads)
+@@ -14,6 +13,5 @@ MUTEX_FUTEX		offsetof (pthread_mutex_t, __data.__lock)
+ -- This way we get the offset of a member in the struct pthread that
+ -- preceeds the thread pointer (which points to the dtv).
+ #define thread_offsetof(mem)    (unsigned int)(offsetof(struct pthread, mem) - sizeof(struct pthread))
+-PID_THREAD_OFFSET		thread_offsetof (pid)
+ TID_THREAD_OFFSET		thread_offsetof (tid)
+ MULTIPLE_THREADS_THREAD_OFFSET	thread_offsetof (header.multiple_threads)
+diff --git a/sysdeps/i386/i686/multiarch/strcspn-c.c b/sysdeps/i386/i686/multiarch/strcspn-c.c
+index 6d61e190a8..ec230fb383 100644
+--- a/sysdeps/i386/i686/multiarch/strcspn-c.c
++++ b/sysdeps/i386/i686/multiarch/strcspn-c.c
+@@ -1,2 +1,4 @@
+-#define __strcspn_sse2 __strcspn_ia32
+-#include <sysdeps/x86_64/multiarch/strcspn-c.c>
++#if IS_IN (libc)
++# define __strcspn_sse2 __strcspn_ia32
++# include <sysdeps/x86_64/multiarch/strcspn-c.c>
++#endif
+diff --git a/sysdeps/i386/i686/multiarch/varshift.c b/sysdeps/i386/i686/multiarch/varshift.c
+index 7760b966e2..6742a35d41 100644
+--- a/sysdeps/i386/i686/multiarch/varshift.c
++++ b/sysdeps/i386/i686/multiarch/varshift.c
+@@ -1 +1,3 @@
+-#include <sysdeps/x86_64/multiarch/varshift.c>
++#if IS_IN (libc)
++# include <sysdeps/x86_64/multiarch/varshift.c>
++#endif
+diff --git a/sysdeps/i386/nptl/tcb-offsets.sym b/sysdeps/i386/nptl/tcb-offsets.sym
+index 7bdf161b29..695a810386 100644
+--- a/sysdeps/i386/nptl/tcb-offsets.sym
++++ b/sysdeps/i386/nptl/tcb-offsets.sym
+@@ -4,7 +4,6 @@
+ 
+ RESULT			offsetof (struct pthread, result)
+ TID			offsetof (struct pthread, tid)
+-PID			offsetof (struct pthread, pid)
+ CANCELHANDLING		offsetof (struct pthread, cancelhandling)
+ CLEANUP_JMP_BUF		offsetof (struct pthread, cleanup_jmp_buf)
+ MULTIPLE_THREADS_OFFSET	offsetof (tcbhead_t, multiple_threads)
+diff --git a/sysdeps/ia64/nptl/Makefile b/sysdeps/ia64/nptl/Makefile
+index 48f1327446..1e6be8eea8 100644
+--- a/sysdeps/ia64/nptl/Makefile
++++ b/sysdeps/ia64/nptl/Makefile
+@@ -21,4 +21,5 @@ endif
+ 
+ ifeq ($(subdir),nptl)
+ libpthread-routines += ptw-sysdep ptw-sigblock ptw-sigprocmask
++libpthread-shared-only-routines += ptw-sysdep ptw-sigblock ptw-sigprocmask
+ endif
+diff --git a/sysdeps/ia64/nptl/tcb-offsets.sym b/sysdeps/ia64/nptl/tcb-offsets.sym
+index e1707ab1c8..b01f712be2 100644
+--- a/sysdeps/ia64/nptl/tcb-offsets.sym
++++ b/sysdeps/ia64/nptl/tcb-offsets.sym
+@@ -1,7 +1,6 @@
+ #include <sysdep.h>
+ #include <tls.h>
+ 
+-PID			offsetof (struct pthread, pid) - TLS_PRE_TCB_SIZE
+ TID			offsetof (struct pthread, tid) - TLS_PRE_TCB_SIZE
+ MULTIPLE_THREADS_OFFSET offsetof (struct pthread, header.multiple_threads) - TLS_PRE_TCB_SIZE
+ SYSINFO_OFFSET		offsetof (tcbhead_t, __private)
+diff --git a/sysdeps/ieee754/dbl-64/e_pow.c b/sysdeps/ieee754/dbl-64/e_pow.c
+index 663fa392c2..bd758b5979 100644
+--- a/sysdeps/ieee754/dbl-64/e_pow.c
++++ b/sysdeps/ieee754/dbl-64/e_pow.c
+@@ -466,15 +466,15 @@ checkint (double x)
+     return (n & 1) ? -1 : 1;	/* odd or even */
+   if (k > 20)
+     {
+-      if (n << (k - 20))
++      if (n << (k - 20) != 0)
+ 	return 0;		/* if not integer */
+-      return (n << (k - 21)) ? -1 : 1;
++      return (n << (k - 21) != 0) ? -1 : 1;
+     }
+   if (n)
+     return 0;			/*if  not integer */
+   if (k == 20)
+     return (m & 1) ? -1 : 1;
+-  if (m << (k + 12))
++  if (m << (k + 12) != 0)
+     return 0;
+-  return (m << (k + 11)) ? -1 : 1;
++  return (m << (k + 11) != 0) ? -1 : 1;
+ }
+diff --git a/sysdeps/m68k/m680x0/m68020/atomic-machine.h b/sysdeps/m68k/m680x0/m68020/atomic-machine.h
+index 24bc5c5ef7..65965cca9e 100644
+--- a/sysdeps/m68k/m680x0/m68020/atomic-machine.h
++++ b/sysdeps/m68k/m680x0/m68020/atomic-machine.h
+@@ -73,7 +73,7 @@ typedef uintmax_t uatomic_max_t;
+      __typeof (mem) __memp = (mem);					      \
+      __asm __volatile ("cas2%.l %0:%R0,%1:%R1,(%2):(%3)"		      \
+ 		       : "=d" (__ret)					      \
+-		       : "d" (newval), "r" (__memp),			      \
++		       : "d" ((__typeof (*(mem))) (newval)), "r" (__memp),    \
+ 			 "r" ((char *) __memp + 4), "0" (oldval)	      \
+ 		       : "memory");					      \
+      __ret; })
+@@ -101,8 +101,9 @@ typedef uintmax_t uatomic_max_t;
+ 	 __asm __volatile ("1: cas2%.l %0:%R0,%1:%R1,(%2):(%3);"	      \
+ 			   "   jbne 1b"					      \
+ 			   : "=d" (__result)				      \
+-			   : "d" (newvalue), "r" (__memp),		      \
+-			     "r" ((char *) __memp + 4), "0" (__result)	      \
++			   : "d" ((__typeof (*(mem))) (newvalue)),	      \
++			     "r" (__memp), "r" ((char *) __memp + 4),	      \
++			     "0" (__result)				      \
+ 			   : "memory");					      \
+        }								      \
+      __result; })
+@@ -144,7 +145,7 @@ typedef uintmax_t uatomic_max_t;
+ 			   "   cas2%.l %0:%R0,%1:%R1,(%3):(%4);"	      \
+ 			   "   jbne 1b"					      \
+ 			   : "=d" (__result), "=&d" (__temp)		      \
+-			   : "d" (value), "r" (__memp),			      \
++			   : "d" ((__typeof (*(mem))) (value)), "r" (__memp), \
+ 			     "r" ((char *) __memp + 4), "0" (__result)	      \
+ 			   : "memory");					      \
+        }								      \
+@@ -175,8 +176,9 @@ typedef uintmax_t uatomic_max_t;
+ 				  "   cas2%.l %0:%R0,%1:%R1,(%3):(%4);"	      \
+ 				  "   jbne 1b"				      \
+ 				  : "=d" (__oldval), "=&d" (__temp)	      \
+-				  : "d" (value), "r" (__memp),		      \
+-				    "r" ((char *) __memp + 4), "0" (__oldval) \
++				  : "d" ((__typeof (*(mem))) (value)),	      \
++				    "r" (__memp), "r" ((char *) __memp + 4),  \
++				    "0" (__oldval)			      \
+ 				  : "memory");				      \
+ 	      }								      \
+ 	    })
+diff --git a/sysdeps/m68k/nptl/tcb-offsets.sym b/sysdeps/m68k/nptl/tcb-offsets.sym
+index b1bba65868..241fb8b47c 100644
+--- a/sysdeps/m68k/nptl/tcb-offsets.sym
++++ b/sysdeps/m68k/nptl/tcb-offsets.sym
+@@ -7,5 +7,4 @@
+ #define thread_offsetof(mem)	(long)(offsetof(struct pthread, mem) - TLS_TCB_OFFSET - TLS_PRE_TCB_SIZE)
+ 
+ MULTIPLE_THREADS_OFFSET		thread_offsetof (header.multiple_threads)
+-PID_OFFSET			thread_offsetof (pid)
+ TID_OFFSET			thread_offsetof (tid)
+diff --git a/sysdeps/microblaze/nptl/tcb-offsets.sym b/sysdeps/microblaze/nptl/tcb-offsets.sym
+index 18afbee291..614f0dfed6 100644
+--- a/sysdeps/microblaze/nptl/tcb-offsets.sym
++++ b/sysdeps/microblaze/nptl/tcb-offsets.sym
+@@ -7,5 +7,4 @@
+ #define thread_offsetof(mem)	(long)(offsetof (struct pthread, mem) - sizeof (struct pthread))
+ 
+ MULTIPLE_THREADS_OFFSET	thread_offsetof (header.multiple_threads)
+-PID_OFFSET			thread_offsetof (pid)
+ TID_OFFSET			thread_offsetof (tid)
+diff --git a/sysdeps/mips/Makefile b/sysdeps/mips/Makefile
+index 3d3552322b..7c1d77941e 100644
+--- a/sysdeps/mips/Makefile
++++ b/sysdeps/mips/Makefile
+@@ -9,6 +9,7 @@ endif
+ 
+ ifeq ($(subdir),rt)
+ librt-sysdep_routines += rt-sysdep
++librt-shared-only-routines += rt-sysdep
+ endif
+ 
+ ifeq ($(subdir),debug)
+diff --git a/sysdeps/mips/mips32/crti.S b/sysdeps/mips/mips32/crti.S
+index 5c0ad7328a..dfbbdc4f8f 100644
+--- a/sysdeps/mips/mips32/crti.S
++++ b/sysdeps/mips/mips32/crti.S
+@@ -74,6 +74,7 @@ _init:
+ 	.reloc 1f,R_MIPS_JALR,PREINIT_FUNCTION
+ 1:	jalr $25
+ .Lno_weak_fn:
++	.insn
+ #else
+ 	lw $25,%got(PREINIT_FUNCTION)($28)
+ 	.reloc 1f,R_MIPS_JALR,PREINIT_FUNCTION
+diff --git a/sysdeps/mips/mips64/n32/crti.S b/sysdeps/mips/mips64/n32/crti.S
+index 00b89f3894..afe6d8edaa 100644
+--- a/sysdeps/mips/mips64/n32/crti.S
++++ b/sysdeps/mips/mips64/n32/crti.S
+@@ -74,6 +74,7 @@ _init:
+ 	.reloc 1f,R_MIPS_JALR,PREINIT_FUNCTION
+ 1:	jalr $25
+ .Lno_weak_fn:
++	.insn
+ #else
+ 	lw $25,%got_disp(PREINIT_FUNCTION)($28)
+ 	.reloc 1f,R_MIPS_JALR,PREINIT_FUNCTION
+diff --git a/sysdeps/mips/mips64/n64/crti.S b/sysdeps/mips/mips64/n64/crti.S
+index f59b20c631..4049d29290 100644
+--- a/sysdeps/mips/mips64/n64/crti.S
++++ b/sysdeps/mips/mips64/n64/crti.S
+@@ -74,6 +74,7 @@ _init:
+ 	.reloc 1f,R_MIPS_JALR,PREINIT_FUNCTION
+ 1:	jalr $25
+ .Lno_weak_fn:
++	.insn
+ #else
+ 	ld $25,%got_disp(PREINIT_FUNCTION)($28)
+ 	.reloc 1f,R_MIPS_JALR,PREINIT_FUNCTION
+diff --git a/sysdeps/mips/nptl/Makefile b/sysdeps/mips/nptl/Makefile
+index 117744ffe2..dda154d842 100644
+--- a/sysdeps/mips/nptl/Makefile
++++ b/sysdeps/mips/nptl/Makefile
+@@ -21,4 +21,5 @@ endif
+ 
+ ifeq ($(subdir),nptl)
+ libpthread-sysdep_routines += nptl-sysdep
++libpthread-shared-only-routines += nptl-sysdep
+ endif
+diff --git a/sysdeps/mips/nptl/tcb-offsets.sym b/sysdeps/mips/nptl/tcb-offsets.sym
+index e0e71dc430..9ea25b94a8 100644
+--- a/sysdeps/mips/nptl/tcb-offsets.sym
++++ b/sysdeps/mips/nptl/tcb-offsets.sym
+@@ -7,5 +7,4 @@
+ #define thread_offsetof(mem)	(long)(offsetof(struct pthread, mem) - TLS_TCB_OFFSET - TLS_PRE_TCB_SIZE)
+ 
+ MULTIPLE_THREADS_OFFSET		thread_offsetof (header.multiple_threads)
+-PID_OFFSET			thread_offsetof (pid)
+ TID_OFFSET			thread_offsetof (tid)
+diff --git a/sysdeps/nacl/clock.c b/sysdeps/nacl/clock.c
+index 664ad650c3..b6fbcfd2dd 100644
+--- a/sysdeps/nacl/clock.c
++++ b/sysdeps/nacl/clock.c
+@@ -24,6 +24,6 @@
+ clock_t
+ clock (void)
+ {
+-  nacl_abi_clock_t result;
++  nacl_irt_clock_t result;
+   return NACL_CALL (__nacl_irt_basic.clock (&result), result);
+ }
+diff --git a/sysdeps/nacl/dup.c b/sysdeps/nacl/dup.c
+index 34a7cd46d4..cbce3f5a5a 100644
+--- a/sysdeps/nacl/dup.c
++++ b/sysdeps/nacl/dup.c
+@@ -27,4 +27,5 @@ __dup (int fd)
+   int result;
+   return NACL_CALL (__nacl_irt_fdio.dup (fd, &result), result);
+ }
++libc_hidden_def (__dup)
+ weak_alias (__dup, dup)
+diff --git a/sysdeps/nios2/nptl/tcb-offsets.sym b/sysdeps/nios2/nptl/tcb-offsets.sym
+index d9ae952585..3cd8d984ac 100644
+--- a/sysdeps/nios2/nptl/tcb-offsets.sym
++++ b/sysdeps/nios2/nptl/tcb-offsets.sym
+@@ -9,6 +9,5 @@
+ # define thread_offsetof(mem)   ((ptrdiff_t) THREAD_SELF + offsetof (struct pthread, mem))
+ 
+ MULTIPLE_THREADS_OFFSET		thread_offsetof (header.multiple_threads)
+-PID_OFFSET			thread_offsetof (pid)
+ TID_OFFSET			thread_offsetof (tid)
+ POINTER_GUARD			(offsetof (tcbhead_t, pointer_guard) - TLS_TCB_OFFSET - sizeof (tcbhead_t))
+diff --git a/sysdeps/nptl/fork.c b/sysdeps/nptl/fork.c
+index 616d897a36..a5d1e86d71 100644
+--- a/sysdeps/nptl/fork.c
++++ b/sysdeps/nptl/fork.c
+@@ -131,16 +131,6 @@ __libc_fork (void)
+       __malloc_fork_lock_parent ();
+     }
+ 
+-#ifndef NDEBUG
+-  pid_t ppid = THREAD_GETMEM (THREAD_SELF, tid);
+-#endif
+-
+-  /* We need to prevent the getpid() code to update the PID field so
+-     that, if a signal arrives in the child very early and the signal
+-     handler uses getpid(), the value returned is correct.  */
+-  pid_t parentpid = THREAD_GETMEM (THREAD_SELF, pid);
+-  THREAD_SETMEM (THREAD_SELF, pid, -parentpid);
+-
+ #ifdef ARCH_FORK
+   pid = ARCH_FORK ();
+ #else
+@@ -153,15 +143,10 @@ __libc_fork (void)
+     {
+       struct pthread *self = THREAD_SELF;
+ 
+-      assert (THREAD_GETMEM (self, tid) != ppid);
+-
+       /* See __pthread_once.  */
+       if (__fork_generation_pointer != NULL)
+ 	*__fork_generation_pointer += __PTHREAD_ONCE_FORK_GEN_INCR;
+ 
+-      /* Adjust the PID field for the new process.  */
+-      THREAD_SETMEM (self, pid, THREAD_GETMEM (self, tid));
+-
+ #if HP_TIMING_AVAIL
+       /* The CPU clock of the thread and process have to be set to zero.  */
+       hp_timing_t now;
+@@ -231,11 +216,6 @@ __libc_fork (void)
+     }
+   else
+     {
+-      assert (THREAD_GETMEM (THREAD_SELF, tid) == ppid);
+-
+-      /* Restore the PID value.  */
+-      THREAD_SETMEM (THREAD_SELF, pid, parentpid);
+-
+       /* Release acquired locks in the multi-threaded case.  */
+       if (multiple_threads)
+ 	{
+diff --git a/sysdeps/posix/wait3.c b/sysdeps/posix/wait3.c
+index cf43d973a7..73722d2be6 100644
+--- a/sysdeps/posix/wait3.c
++++ b/sysdeps/posix/wait3.c
+@@ -33,7 +33,7 @@ __wait3 (int *stat_loc, int options, struct rusage *usage)
+       __set_errno (ENOSYS);
+       return (pid_t) -1;
+     }
+-  return __waitpid (WAIT_ANY, stat_loc.__iptr, options);
++  return __waitpid (WAIT_ANY, stat_loc, options);
+ }
+ 
+ weak_alias (__wait3, wait3)
+diff --git a/sysdeps/powerpc/fpu/libm-test-ulps b/sysdeps/powerpc/fpu/libm-test-ulps
+index 7f37c813d0..36b700c520 100644
+--- a/sysdeps/powerpc/fpu/libm-test-ulps
++++ b/sysdeps/powerpc/fpu/libm-test-ulps
+@@ -36,8 +36,8 @@ double: 2
+ float: 2
+ idouble: 2
+ ifloat: 2
+-ildouble: 1
+-ldouble: 1
++ildouble: 2
++ldouble: 2
+ 
+ Function: "acosh_downward":
+ double: 1
+@@ -52,8 +52,8 @@ double: 2
+ float: 2
+ idouble: 2
+ ifloat: 2
+-ildouble: 3
+-ldouble: 3
++ildouble: 4
++ldouble: 4
+ 
+ Function: "acosh_upward":
+ double: 2
+@@ -122,8 +122,8 @@ double: 3
+ float: 3
+ idouble: 3
+ ifloat: 3
+-ildouble: 4
+-ldouble: 4
++ildouble: 7
++ldouble: 7
+ 
+ Function: "atan":
+ double: 1
+@@ -216,8 +216,8 @@ double: 3
+ float: 3
+ idouble: 3
+ ifloat: 3
+-ildouble: 3
+-ldouble: 3
++ildouble: 4
++ldouble: 4
+ 
+ Function: "cabs":
+ double: 1
+@@ -272,8 +272,8 @@ double: 5
+ float: 3
+ idouble: 5
+ ifloat: 3
+-ildouble: 5
+-ldouble: 5
++ildouble: 8
++ldouble: 8
+ 
+ Function: Real part of "cacos_towardzero":
+ double: 2
+@@ -288,8 +288,8 @@ double: 5
+ float: 3
+ idouble: 5
+ ifloat: 3
+-ildouble: 5
+-ldouble: 5
++ildouble: 8
++ldouble: 8
+ 
+ Function: Real part of "cacos_upward":
+ double: 2
+@@ -328,8 +328,8 @@ double: 5
+ float: 3
+ idouble: 5
+ ifloat: 3
+-ildouble: 5
+-ldouble: 5
++ildouble: 8
++ldouble: 8
+ 
+ Function: Imaginary part of "cacosh_downward":
+ double: 2
+@@ -344,8 +344,8 @@ double: 5
+ float: 3
+ idouble: 5
+ ifloat: 3
+-ildouble: 5
+-ldouble: 5
++ildouble: 8
++ldouble: 8
+ 
+ Function: Imaginary part of "cacosh_towardzero":
+ double: 2
+@@ -432,8 +432,8 @@ double: 5
+ float: 3
+ idouble: 5
+ ifloat: 3
+-ildouble: 5
+-ldouble: 5
++ildouble: 8
++ldouble: 8
+ 
+ Function: Real part of "casin_towardzero":
+ double: 3
+@@ -448,8 +448,8 @@ double: 5
+ float: 3
+ idouble: 5
+ ifloat: 3
+-ildouble: 5
+-ldouble: 5
++ildouble: 8
++ldouble: 8
+ 
+ Function: Real part of "casin_upward":
+ double: 2
+@@ -488,8 +488,8 @@ double: 5
+ float: 3
+ idouble: 5
+ ifloat: 3
+-ildouble: 5
+-ldouble: 5
++ildouble: 8
++ldouble: 8
+ 
+ Function: Imaginary part of "casinh_downward":
+ double: 3
+@@ -504,8 +504,8 @@ double: 5
+ float: 3
+ idouble: 5
+ ifloat: 3
+-ildouble: 5
+-ldouble: 5
++ildouble: 8
++ldouble: 8
+ 
+ Function: Imaginary part of "casinh_towardzero":
+ double: 3
+@@ -696,8 +696,8 @@ double: 1
+ float: 1
+ idouble: 1
+ ifloat: 1
+-ildouble: 1
+-ldouble: 1
++ildouble: 2
++ldouble: 2
+ 
+ Function: Real part of "ccos_downward":
+ double: 1
+@@ -1132,8 +1132,8 @@ double: 1
+ float: 1
+ idouble: 1
+ ifloat: 1
+-ildouble: 1
+-ldouble: 1
++ildouble: 2
++ldouble: 2
+ 
+ Function: Imaginary part of "csin":
+ ildouble: 1
+@@ -1198,8 +1198,8 @@ double: 1
+ float: 1
+ idouble: 1
+ ifloat: 1
+-ildouble: 1
+-ldouble: 1
++ildouble: 2
++ldouble: 2
+ 
+ Function: Real part of "csinh_downward":
+ double: 2
+@@ -1318,8 +1318,8 @@ double: 1
+ float: 1
+ idouble: 1
+ ifloat: 1
+-ildouble: 2
+-ldouble: 2
++ildouble: 3
++ldouble: 3
+ 
+ Function: Imaginary part of "ctan":
+ double: 2
+@@ -1390,8 +1390,8 @@ double: 2
+ float: 1
+ idouble: 2
+ ifloat: 1
+-ildouble: 2
+-ldouble: 2
++ildouble: 3
++ldouble: 3
+ 
+ Function: Real part of "ctanh_downward":
+ double: 4
+@@ -1478,8 +1478,8 @@ double: 2
+ float: 2
+ idouble: 2
+ ifloat: 2
+-ildouble: 2
+-ldouble: 2
++ildouble: 3
++ldouble: 3
+ 
+ Function: "erfc_downward":
+ double: 3
+@@ -1564,8 +1564,8 @@ double: 1
+ float: 1
+ idouble: 1
+ ifloat: 1
+-ildouble: 1
+-ldouble: 1
++ildouble: 2
++ldouble: 2
+ 
+ Function: "exp2_upward":
+ double: 1
+@@ -1588,8 +1588,8 @@ ildouble: 2
+ ldouble: 2
+ 
+ Function: "exp_upward":
+-float: 1
+ double: 1
++float: 1
+ idouble: 1
+ ifloat: 1
+ ildouble: 1
+@@ -1624,8 +1624,8 @@ double: 1
+ float: 1
+ idouble: 1
+ ifloat: 1
+-ildouble: 4
+-ldouble: 4
++ildouble: 6
++ldouble: 6
+ 
+ Function: "fma":
+ ildouble: 1
+@@ -1688,8 +1688,8 @@ double: 4
+ float: 5
+ idouble: 4
+ ifloat: 5
+-ildouble: 10
+-ldouble: 10
++ildouble: 11
++ldouble: 11
+ 
+ Function: "hypot":
+ double: 1
+@@ -1752,8 +1752,8 @@ double: 1
+ float: 2
+ idouble: 1
+ ifloat: 2
+-ildouble: 1
+-ldouble: 1
++ildouble: 2
++ldouble: 2
+ 
+ Function: "j1_downward":
+ double: 3
+@@ -1840,8 +1840,8 @@ double: 4
+ float: 5
+ idouble: 4
+ ifloat: 5
+-ildouble: 10
+-ldouble: 10
++ildouble: 11
++ldouble: 11
+ 
+ Function: "log":
+ float: 1
+@@ -1910,8 +1910,8 @@ double: 2
+ float: 2
+ idouble: 2
+ ifloat: 2
+-ildouble: 2
+-ldouble: 2
++ildouble: 3
++ldouble: 3
+ 
+ Function: "log2":
+ double: 1
+@@ -2184,16 +2184,16 @@ double: 3
+ float: 3
+ idouble: 3
+ ifloat: 3
+-ildouble: 3
+-ldouble: 3
++ildouble: 4
++ldouble: 4
+ 
+ Function: "tanh_towardzero":
+ double: 2
+ float: 2
+ idouble: 2
+ ifloat: 2
+-ildouble: 3
+-ldouble: 3
++ildouble: 4
++ldouble: 4
+ 
+ Function: "tanh_upward":
+ double: 3
+diff --git a/sysdeps/powerpc/ifunc-sel.h b/sysdeps/powerpc/ifunc-sel.h
+index 526d8ed88b..ac589bd3c0 100644
+--- a/sysdeps/powerpc/ifunc-sel.h
++++ b/sysdeps/powerpc/ifunc-sel.h
+@@ -17,15 +17,17 @@ ifunc_sel (int (*f1) (void), int (*f2) (void), int (*f3) (void))
+ 	   "addis %0,11,%2-1b@ha\n\t"
+ 	   "addi %0,%0,%2-1b@l\n\t"
+ 	   "cmpwi 12,1\n\t"
+-	   "beqlr\n\t"
++	   "beq 2f\n\t"
+ 	   "addis %0,11,%3-1b@ha\n\t"
+ 	   "addi %0,%0,%3-1b@l\n\t"
+ 	   "cmpwi 12,-1\n\t"
+-	   "beqlr\n\t"
++	   "beq 2f\n\t"
+ 	   "addis %0,11,%4-1b@ha\n\t"
+-	   "addi %0,%0,%4-1b@l"
++	   "addi %0,%0,%4-1b@l\n\t"
++	   "2:"
+ 	   : "=r" (ret)
+-	   : "X" (&global), "X" (f1), "X" (f2), "X" (f3));
++	   : "i" (&global), "i" (f1), "i" (f2), "i" (f3)
++	   : "11", "12", "cr0");
+   return ret;
+ }
+ 
+@@ -40,7 +42,8 @@ ifunc_one (int (*f1) (void))
+ 	   "addis %0,%0,%1-1b@ha\n\t"
+ 	   "addi %0,%0,%1-1b@l"
+ 	   : "=r" (ret)
+-	   : "X" (f1));
++	   : "i" (f1)
++	   : "12");
+   return ret;
+ }
+ #endif
+diff --git a/sysdeps/powerpc/nptl/tcb-offsets.sym b/sysdeps/powerpc/nptl/tcb-offsets.sym
+index f580e69555..7c9fd33562 100644
+--- a/sysdeps/powerpc/nptl/tcb-offsets.sym
++++ b/sysdeps/powerpc/nptl/tcb-offsets.sym
+@@ -13,7 +13,6 @@
+ #if TLS_MULTIPLE_THREADS_IN_TCB
+ MULTIPLE_THREADS_OFFSET		thread_offsetof (header.multiple_threads)
+ #endif
+-PID				thread_offsetof (pid)
+ TID				thread_offsetof (tid)
+ POINTER_GUARD			(offsetof (tcbhead_t, pointer_guard) - TLS_TCB_OFFSET - sizeof (tcbhead_t))
+ TAR_SAVE			(offsetof (tcbhead_t, tar_save) - TLS_TCB_OFFSET - sizeof (tcbhead_t))
+diff --git a/sysdeps/powerpc/powerpc32/power6/memset.S b/sysdeps/powerpc/powerpc32/power6/memset.S
+index b2a222edd2..d5dbe83af2 100644
+--- a/sysdeps/powerpc/powerpc32/power6/memset.S
++++ b/sysdeps/powerpc/powerpc32/power6/memset.S
+@@ -394,7 +394,7 @@ L(cacheAlignedx):
+ /* A simple loop for the longer (>640 bytes) lengths.  This form limits
+    the branch miss-predicted to exactly 1 at loop exit.*/
+ L(cacheAligned512):
+-	cmpli	cr1,rLEN,128
++	cmplwi	cr1,rLEN,128
+ 	blt	cr1,L(cacheAligned1)
+ 	dcbz	0,rMEMP
+ 	addi	rLEN,rLEN,-128
+diff --git a/sysdeps/powerpc/powerpc32/power9/multiarch/Implies b/sysdeps/powerpc/powerpc32/power9/multiarch/Implies
+index 4393b56872..1a46ef0035 100644
+--- a/sysdeps/powerpc/powerpc32/power9/multiarch/Implies
++++ b/sysdeps/powerpc/powerpc32/power9/multiarch/Implies
+@@ -1 +1 @@
+-powerpc/powerpc32/power8/fpu/multiarch
++powerpc/powerpc32/power8/multiarch
+diff --git a/sysdeps/powerpc/powerpc64/power6/memset.S b/sysdeps/powerpc/powerpc64/power6/memset.S
+index c2d1c4e600..d445b1e1ef 100644
+--- a/sysdeps/powerpc/powerpc64/power6/memset.S
++++ b/sysdeps/powerpc/powerpc64/power6/memset.S
+@@ -251,7 +251,7 @@ L(cacheAlignedx):
+ /* A simple loop for the longer (>640 bytes) lengths.  This form limits
+    the branch miss-predicted to exactly 1 at loop exit.*/
+ L(cacheAligned512):
+-	cmpli	cr1,rLEN,128
++	cmpldi	cr1,rLEN,128
+ 	blt	cr1,L(cacheAligned1)
+ 	dcbz	0,rMEMP
+ 	addi	rLEN,rLEN,-128
+diff --git a/sysdeps/powerpc/powerpc64/power9/fpu/Implies b/sysdeps/powerpc/powerpc64/power9/fpu/Implies
+index fad2505ab9..ae0dbaf857 100644
+--- a/sysdeps/powerpc/powerpc64/power9/fpu/Implies
++++ b/sysdeps/powerpc/powerpc64/power9/fpu/Implies
+@@ -1,2 +1 @@
+ powerpc/powerpc64/power8/fpu
+-powerpc/powerpc64/power8
+diff --git a/sysdeps/s390/nptl/Makefile b/sysdeps/s390/nptl/Makefile
+index 5734b983b0..3a391c8217 100644
+--- a/sysdeps/s390/nptl/Makefile
++++ b/sysdeps/s390/nptl/Makefile
+@@ -21,4 +21,5 @@ endif
+ 
+ ifeq ($(subdir),nptl)
+ libpthread-routines += ptw-sysdep
++libpthread-shared-only-routines += ptw-sysdep
+ endif
+diff --git a/sysdeps/s390/nptl/tcb-offsets.sym b/sysdeps/s390/nptl/tcb-offsets.sym
+index 9cfae211e0..9c1c01f353 100644
+--- a/sysdeps/s390/nptl/tcb-offsets.sym
++++ b/sysdeps/s390/nptl/tcb-offsets.sym
+@@ -3,5 +3,4 @@
+ 
+ MULTIPLE_THREADS_OFFSET		offsetof (tcbhead_t, multiple_threads)
+ STACK_GUARD			offsetof (tcbhead_t, stack_guard)
+-PID				offsetof (struct pthread, pid)
+ TID				offsetof (struct pthread, tid)
+diff --git a/sysdeps/sh/nptl/tcb-offsets.sym b/sysdeps/sh/nptl/tcb-offsets.sym
+index ac63b5b93b..4963e1506f 100644
+--- a/sysdeps/sh/nptl/tcb-offsets.sym
++++ b/sysdeps/sh/nptl/tcb-offsets.sym
+@@ -4,7 +4,6 @@
+ 
+ RESULT			offsetof (struct pthread, result)
+ TID			offsetof (struct pthread, tid)
+-PID			offsetof (struct pthread, pid)
+ CANCELHANDLING		offsetof (struct pthread, cancelhandling)
+ CLEANUP_JMP_BUF		offsetof (struct pthread, cleanup_jmp_buf)
+ MULTIPLE_THREADS_OFFSET	offsetof (struct pthread, header.multiple_threads)
+diff --git a/sysdeps/sparc/nptl/tcb-offsets.sym b/sysdeps/sparc/nptl/tcb-offsets.sym
+index 923af8a5b7..f75d02065e 100644
+--- a/sysdeps/sparc/nptl/tcb-offsets.sym
++++ b/sysdeps/sparc/nptl/tcb-offsets.sym
+@@ -3,5 +3,4 @@
+ 
+ MULTIPLE_THREADS_OFFSET		offsetof (tcbhead_t, multiple_threads)
+ POINTER_GUARD			offsetof (tcbhead_t, pointer_guard)
+-PID				offsetof (struct pthread, pid)
+ TID				offsetof (struct pthread, tid)
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/Makefile b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/Makefile
+index ebbe28b07f..13d3c6db51 100644
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/Makefile
++++ b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/Makefile
+@@ -4,8 +4,8 @@ libm-sysdep_routines += m_copysignf-vis3 m_copysign-vis3 s_fabs-vis3 \
+ 			s_fabsf-vis3 s_llrintf-vis3 s_llrint-vis3 \
+ 			s_rintf-vis3 s_rint-vis3 w_sqrt-vis3 w_sqrtf-vis3 \
+ 			s_fminf-vis3 s_fmin-vis3 s_fmaxf-vis3 s_fmax-vis3 \
+-			s_fmaf-vis3 s_fma-vis3 s_fdimf-vis3 s_fdim-vis3 \
+-			s_nearbyint-vis3 s_nearbyintf-vis3
++			s_fmaf-vis3 s_fma-vis3 s_nearbyint-vis3 \
++			s_nearbyintf-vis3
+ sysdep_routines += s_copysignf-vis3 s_copysign-vis3
+ endif
+ endif
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdim.S b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdim.S
+deleted file mode 100644
+index 4b13408244..0000000000
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdim.S
++++ /dev/null
+@@ -1,19 +0,0 @@
+-#include <sparc-ifunc.h>
+-#include <math_ldbl_opt.h>
+-
+-SPARC_ASM_VIS3_IFUNC(fdim)
+-
+-weak_alias (__fdim, fdim)
+-
+-#if LONG_DOUBLE_COMPAT(libm, GLIBC_2_1)
+-compat_symbol (libm, __fdim, fdiml, GLIBC_2_1);
+-#endif
+-
+-# undef weak_alias
+-# define weak_alias(a, b)
+-# undef compat_symbol
+-# define compat_symbol(a, b, c, d)
+-
+-#define __fdim __fdim_generic
+-
+-#include "../s_fdim.S"
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdimf.S b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdimf.S
+deleted file mode 100644
+index 30381d6a59..0000000000
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_fdimf.S
++++ /dev/null
+@@ -1,12 +0,0 @@
+-#include <sparc-ifunc.h>
+-
+-SPARC_ASM_VIS3_IFUNC(fdimf)
+-
+-weak_alias (__fdimf, fdimf)
+-
+-# undef weak_alias
+-# define weak_alias(a, b)
+-
+-#define __fdimf __fdimf_generic
+-
+-#include "../s_fdimf.S"
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_nearbyint-vis3.S b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_nearbyint-vis3.S
+index d9ff0cc288..ff81b0da83 100644
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_nearbyint-vis3.S
++++ b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_nearbyint-vis3.S
+@@ -36,15 +36,15 @@
+ #define SIGN_BIT	%f12			/* -0.0 */
+ 
+ ENTRY (__nearbyint_vis3)
++	sllx	%o0, 32, %o0
++	or	%o0, %o1, %o0
++	movxtod	%o0, %f0
+ 	fcmpd	%fcc3, %f0, %f0			/* Check for sNaN */
+ 	st	%fsr, [%sp + 88]
+ 	sethi	%hi(TWO_FIFTYTWO), %o2
+ 	sethi	%hi(0xf8003e0), %o5
+ 	ld	[%sp + 88], %o4
+-	sllx	%o0, 32, %o0
+ 	or	%o5, %lo(0xf8003e0), %o5
+-	or	%o0, %o1, %o0
+-	movxtod	%o0, %f0
+ 	andn	%o4, %o5, %o4
+ 	fzero	ZERO
+ 	st	%o4, [%sp + 80]
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_nearbyintf-vis3.S b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_nearbyintf-vis3.S
+index 5cd1eb02db..833a0dfc24 100644
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_nearbyintf-vis3.S
++++ b/sysdeps/sparc/sparc32/sparcv9/fpu/multiarch/s_nearbyintf-vis3.S
+@@ -35,9 +35,9 @@
+ #define SIGN_BIT	%f12			/* -0.0 */
+ 
+ ENTRY (__nearbyintf_vis3)
++	movwtos	%o0, %f1
+ 	fcmps	%fcc3, %f1, %f1			/* Check for sNaN */
+ 	st	%fsr, [%sp + 88]
+-	movwtos	%o0, %f1
+ 	sethi	%hi(TWO_TWENTYTHREE), %o2
+ 	sethi	%hi(0xf8003e0), %o5
+ 	ld	[%sp + 88], %o4
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/s_nearbyint.S b/sysdeps/sparc/sparc32/sparcv9/fpu/s_nearbyint.S
+index 84a10971a4..198440a5bc 100644
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/s_nearbyint.S
++++ b/sysdeps/sparc/sparc32/sparcv9/fpu/s_nearbyint.S
+@@ -36,21 +36,21 @@
+ #define SIGN_BIT	%f12			/* -0.0 */
+ 
+ ENTRY (__nearbyint)
++	sllx	%o0, 32, %o0
++	or	%o0, %o1, %o0
++	stx	%o0, [%sp + 72]
++	ldd	[%sp + 72], %f0
+ 	fcmpd	%fcc3, %f0, %f0			/* Check for sNaN */
+ 	st	%fsr, [%sp + 88]
+ 	sethi	%hi(TWO_FIFTYTWO), %o2
+ 	sethi	%hi(0xf8003e0), %o5
+ 	ld	[%sp + 88], %o4
+-	sllx	%o0, 32, %o0
+ 	or	%o5, %lo(0xf8003e0), %o5
+-	or	%o0, %o1, %o0
+ 	andn	%o4, %o5, %o4
+ 	fzero	ZERO
+ 	st	%o4, [%sp + 80]
+-	stx	%o0, [%sp + 72]
+ 	sllx	%o2, 32, %o2
+ 	fnegd	ZERO, SIGN_BIT
+-	ldd	[%sp + 72], %f0
+ 	ld	[%sp + 80], %fsr
+ 	stx	%o2, [%sp + 72]
+ 	fabsd	%f0, %f14
+diff --git a/sysdeps/sparc/sparc32/sparcv9/fpu/s_nearbyintf.S b/sysdeps/sparc/sparc32/sparcv9/fpu/s_nearbyintf.S
+index d5cf5ce815..9be41f6c22 100644
+--- a/sysdeps/sparc/sparc32/sparcv9/fpu/s_nearbyintf.S
++++ b/sysdeps/sparc/sparc32/sparcv9/fpu/s_nearbyintf.S
+@@ -35,9 +35,10 @@
+ #define SIGN_BIT	%f12			/* -0.0 */
+ 
+ ENTRY (__nearbyintf)
++	st	%o0, [%sp + 68]
++	ld	[%sp + 68], %f1
+ 	fcmps	%fcc3, %f1, %f1			/* Check for sNaN */
+ 	st	%fsr, [%sp + 88]
+-	st	%o0, [%sp + 68]
+ 	sethi	%hi(TWO_TWENTYTHREE), %o2
+ 	sethi	%hi(0xf8003e0), %o5
+ 	ld	[%sp + 88], %o4
+@@ -46,7 +47,6 @@ ENTRY (__nearbyintf)
+ 	fnegs	ZERO, SIGN_BIT
+ 	andn	%o4, %o5, %o4
+ 	st	%o4, [%sp + 80]
+-	ld	[%sp + 68], %f1
+ 	ld	[%sp + 80], %fsr
+ 	st	%o2, [%sp + 68]
+ 	fabss	%f1, %f14
+diff --git a/sysdeps/tile/nptl/tcb-offsets.sym b/sysdeps/tile/nptl/tcb-offsets.sym
+index 6740bc976f..0147ffafb7 100644
+--- a/sysdeps/tile/nptl/tcb-offsets.sym
++++ b/sysdeps/tile/nptl/tcb-offsets.sym
+@@ -9,7 +9,6 @@
+ #define thread_offsetof(mem)	(long)(offsetof(struct pthread, mem) - TLS_TCB_OFFSET - TLS_PRE_TCB_SIZE)
+ 
+ MULTIPLE_THREADS_OFFSET		thread_offsetof (header.multiple_threads)
+-PID_OFFSET			thread_offsetof (pid)
+ TID_OFFSET			thread_offsetof (tid)
+ POINTER_GUARD			(offsetof (tcbhead_t, pointer_guard) - TLS_TCB_OFFSET - sizeof (tcbhead_t))
+ FEEDBACK_DATA_OFFSET		(offsetof (tcbhead_t, feedback_data) - TLS_TCB_OFFSET - sizeof (tcbhead_t))
+diff --git a/sysdeps/unix/alpha/Makefile b/sysdeps/unix/alpha/Makefile
+index 441aa02a83..0660847f15 100644
+--- a/sysdeps/unix/alpha/Makefile
++++ b/sysdeps/unix/alpha/Makefile
+@@ -1,3 +1,4 @@
+ ifeq ($(subdir),rt)
+ librt-sysdep_routines += rt-sysdep
++librt-shared-only-routines += rt-sysdep
+ endif
+diff --git a/sysdeps/unix/sysdep.h b/sysdeps/unix/sysdep.h
+index 94a2ce0e37..38c2432002 100644
+--- a/sysdeps/unix/sysdep.h
++++ b/sysdeps/unix/sysdep.h
+@@ -24,42 +24,79 @@
+ #define	SYSCALL__(name, args)	PSEUDO (__##name, name, args)
+ #define	SYSCALL(name, args)	PSEUDO (name, name, args)
+ 
+-#define __SYSCALL0(name) \
++#define __SYSCALL_CONCAT_X(a,b)     a##b
++#define __SYSCALL_CONCAT(a,b)       __SYSCALL_CONCAT_X (a, b)
++
++
++#define __INTERNAL_SYSCALL0(name, err) \
++  INTERNAL_SYSCALL (name, err, 0)
++#define __INTERNAL_SYSCALL1(name, err, a1) \
++  INTERNAL_SYSCALL (name, err, 1, a1)
++#define __INTERNAL_SYSCALL2(name, err, a1, a2) \
++  INTERNAL_SYSCALL (name, err, 2, a1, a2)
++#define __INTERNAL_SYSCALL3(name, err, a1, a2, a3) \
++  INTERNAL_SYSCALL (name, err, 3, a1, a2, a3)
++#define __INTERNAL_SYSCALL4(name, err, a1, a2, a3, a4) \
++  INTERNAL_SYSCALL (name, err, 4, a1, a2, a3, a4)
++#define __INTERNAL_SYSCALL5(name, err, a1, a2, a3, a4, a5) \
++  INTERNAL_SYSCALL (name, err, 5, a1, a2, a3, a4, a5)
++#define __INTERNAL_SYSCALL6(name, err, a1, a2, a3, a4, a5, a6) \
++  INTERNAL_SYSCALL (name, err, 6, a1, a2, a3, a4, a5, a6)
++#define __INTERNAL_SYSCALL7(name, err, a1, a2, a3, a4, a5, a6, a7) \
++  INTERNAL_SYSCALL (name, err, 7, a1, a2, a3, a4, a5, a6, a7)
++
++#define __INTERNAL_SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,o,...) o
++#define __INTERNAL_SYSCALL_NARGS(...) \
++  __INTERNAL_SYSCALL_NARGS_X (__VA_ARGS__,7,6,5,4,3,2,1,0,)
++#define __INTERNAL_SYSCALL_DISP(b,...) \
++  __SYSCALL_CONCAT (b,__INTERNAL_SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
++
++/* Issue a syscall defined by syscall number plus any other argument required.
++   It is similar to INTERNAL_SYSCALL macro, but without the need to pass the
++   expected argument number as second parameter.  */
++#define INTERNAL_SYSCALL_CALL(...) \
++  __INTERNAL_SYSCALL_DISP (__INTERNAL_SYSCALL, __VA_ARGS__)
++
++#define __INLINE_SYSCALL0(name) \
+   INLINE_SYSCALL (name, 0)
+-#define __SYSCALL1(name, a1) \
++#define __INLINE_SYSCALL1(name, a1) \
+   INLINE_SYSCALL (name, 1, a1)
+-#define __SYSCALL2(name, a1, a2) \
++#define __INLINE_SYSCALL2(name, a1, a2) \
+   INLINE_SYSCALL (name, 2, a1, a2)
+-#define __SYSCALL3(name, a1, a2, a3) \
++#define __INLINE_SYSCALL3(name, a1, a2, a3) \
+   INLINE_SYSCALL (name, 3, a1, a2, a3)
+-#define __SYSCALL4(name, a1, a2, a3, a4) \
++#define __INLINE_SYSCALL4(name, a1, a2, a3, a4) \
+   INLINE_SYSCALL (name, 4, a1, a2, a3, a4)
+-#define __SYSCALL5(name, a1, a2, a3, a4, a5) \
++#define __INLINE_SYSCALL5(name, a1, a2, a3, a4, a5) \
+   INLINE_SYSCALL (name, 5, a1, a2, a3, a4, a5)
+-#define __SYSCALL6(name, a1, a2, a3, a4, a5, a6) \
++#define __INLINE_SYSCALL6(name, a1, a2, a3, a4, a5, a6) \
+   INLINE_SYSCALL (name, 6, a1, a2, a3, a4, a5, a6)
+-#define __SYSCALL7(name, a1, a2, a3, a4, a5, a6, a7) \
++#define __INLINE_SYSCALL7(name, a1, a2, a3, a4, a5, a6, a7) \
+   INLINE_SYSCALL (name, 7, a1, a2, a3, a4, a5, a6, a7)
+ 
+-#define __SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,...) n
+-#define __SYSCALL_NARGS(...) \
+-  __SYSCALL_NARGS_X (__VA_ARGS__,7,6,5,4,3,2,1,0,)
+-#define __SYSCALL_CONCAT_X(a,b)     a##b
+-#define __SYSCALL_CONCAT(a,b)       __SYSCALL_CONCAT_X (a, b)
+-#define __SYSCALL_DISP(b,...) \
+-  __SYSCALL_CONCAT (b,__SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
++#define __INLINE_SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,...) n
++#define __INLINE_SYSCALL_NARGS(...) \
++  __INLINE_SYSCALL_NARGS_X (__VA_ARGS__,7,6,5,4,3,2,1,0,)
++#define __INLINE_SYSCALL_DISP(b,...) \
++  __SYSCALL_CONCAT (b,__INLINE_SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__)
+ 
+-#define __SYSCALL_CALL(...) __SYSCALL_DISP (__SYSCALL, __VA_ARGS__)
++/* Issue a syscall defined by syscall number plus any other argument
++   required.  Any error will be handled using arch defined macros and errno
++   will be set accordingly.
++   It is similar to INLINE_SYSCALL macro, but without the need to pass the
++   expected argument number as second parameter.  */
++#define INLINE_SYSCALL_CALL(...) \
++  __INLINE_SYSCALL_DISP (__INLINE_SYSCALL, __VA_ARGS__)
+ 
+ #define SYSCALL_CANCEL(...) \
+   ({									     \
+     long int sc_ret;							     \
+     if (SINGLE_THREAD_P) 						     \
+-      sc_ret = __SYSCALL_CALL (__VA_ARGS__);   				     \
++      sc_ret = INLINE_SYSCALL_CALL (__VA_ARGS__); 			     \
+     else								     \
+       {									     \
+ 	int sc_cancel_oldtype = LIBC_CANCEL_ASYNC ();			     \
+-	sc_ret = __SYSCALL_CALL (__VA_ARGS__);				     \
++	sc_ret = INLINE_SYSCALL_CALL (__VA_ARGS__);			     \
+         LIBC_CANCEL_RESET (sc_cancel_oldtype);				     \
+       }									     \
+     sc_ret;								     \
+diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile
+index 35e1ed48d2..32beaa67d0 100644
+--- a/sysdeps/unix/sysv/linux/Makefile
++++ b/sysdeps/unix/sysv/linux/Makefile
+@@ -140,7 +140,7 @@ endif
+ ifeq ($(subdir),posix)
+ sysdep_headers += bits/initspin.h
+ 
+-sysdep_routines += sched_getcpu
++sysdep_routines += sched_getcpu oldglob
+ 
+ tests += tst-affinity tst-affinity-pid
+ 
+diff --git a/sysdeps/unix/sysv/linux/aarch64/clone.S b/sysdeps/unix/sysv/linux/aarch64/clone.S
+index 76baa7a698..96482e53c0 100644
+--- a/sysdeps/unix/sysv/linux/aarch64/clone.S
++++ b/sysdeps/unix/sysv/linux/aarch64/clone.S
+@@ -72,16 +72,6 @@ thread_start:
+ 	cfi_undefined (x30)
+ 	mov	x29, 0
+ 
+-	tbnz	x11, #CLONE_VM_BIT, 1f
+-
+-	mov	x8, #SYS_ify(getpid)
+-	svc	0x0
+-	mrs	x1, tpidr_el0
+-	sub	x1, x1, #PTHREAD_SIZEOF
+-	str	w0, [x1, #PTHREAD_PID_OFFSET]
+-	str	w0, [x1, #PTHREAD_TID_OFFSET]
+-1:
+-
+ 	/* Pick the function arg and execute.  */
+ 	mov	x0, x12
+ 	blr	x10
+diff --git a/sysdeps/unix/sysv/linux/aarch64/vfork.S b/sysdeps/unix/sysv/linux/aarch64/vfork.S
+index 577895eeb2..aeed0b29ce 100644
+--- a/sysdeps/unix/sysv/linux/aarch64/vfork.S
++++ b/sysdeps/unix/sysv/linux/aarch64/vfork.S
+@@ -27,27 +27,10 @@
+ 
+ ENTRY (__vfork)
+ 
+-	/* Save the TCB-cached PID away in w3, and then negate the TCB
+-           field.  But if it's zero, set it to 0x80000000 instead.  See
+-           raise.c for the logic that relies on this value.  */
+-	mrs	x2, tpidr_el0
+-	sub	x2, x2, #PTHREAD_SIZEOF
+-	ldr	w3, [x2, #PTHREAD_PID_OFFSET]
+-	mov	w1, #0x80000000
+-	negs	w0, w3
+-	csel	w0, w1, w0, eq
+-	str	w0, [x2, #PTHREAD_PID_OFFSET]
+-
+ 	mov	x0, #0x4111	/* CLONE_VM | CLONE_VFORK | SIGCHLD */
+ 	mov	x1, sp
+ 	DO_CALL (clone, 2)
+ 
+-	/* Restore the original value of the TCB cache of the PID, if we're
+-	   the parent.  But in the child (syscall return value equals zero),
+-	   leave things as they are.  */
+-	cbz	x0, 1f
+-	str	w3, [x2, #PTHREAD_PID_OFFSET]
+-1:
+ 	cmn	x0, #4095
+ 	b.cs    .Lsyscall_error
+ 	RET
+diff --git a/sysdeps/unix/sysv/linux/alpha/Makefile b/sysdeps/unix/sysv/linux/alpha/Makefile
+index c089545e9b..3b523b70cf 100644
+--- a/sysdeps/unix/sysv/linux/alpha/Makefile
++++ b/sysdeps/unix/sysv/linux/alpha/Makefile
+@@ -40,4 +40,5 @@ endif   # math
+ ifeq ($(subdir),nptl)
+ # pull in __syscall_error routine, __sigprocmask, __syscall_rt_sigaction
+ libpthread-routines += ptw-sysdep ptw-sigprocmask ptw-rt_sigaction
++libpthread-shared-only-routines += ptw-sysdep ptw-sigprocmask ptw-rt_sigaction
+ endif
+diff --git a/sysdeps/unix/sysv/linux/alpha/clone.S b/sysdeps/unix/sysv/linux/alpha/clone.S
+index 6a3154f9a7..2757bf20c3 100644
+--- a/sysdeps/unix/sysv/linux/alpha/clone.S
++++ b/sysdeps/unix/sysv/linux/alpha/clone.S
+@@ -91,13 +91,6 @@ thread_start:
+ 	cfi_def_cfa_register(fp)
+ 	cfi_undefined(ra)
+ 
+-	/* Check and see if we need to reset the PID.  */
+-	ldq	t0, 16(sp)
+-	lda	t1, CLONE_VM
+-	and	t0, t1, t2
+-	beq	t2, 2f
+-1:
+-
+ 	/* Load up the arguments.  */
+ 	ldq	pv, 0(sp)
+ 	ldq	a0, 8(sp)
+@@ -120,15 +113,6 @@ thread_start:
+ 	halt
+ 
+ 	.align	4
+-2:
+-	rduniq
+-	mov	v0, s0
+-	lda	v0, __NR_getxpid
+-	callsys
+-3:
+-	stl	v0, PID_OFFSET(s0)
+-	stl	v0, TID_OFFSET(s0)
+-	br	1b
+ 	cfi_endproc
+ 	.end thread_start
+ 
+diff --git a/sysdeps/unix/sysv/linux/alpha/glob.c b/sysdeps/unix/sysv/linux/alpha/glob.c
+index c5dfb85468..19eb9b1c07 100644
+--- a/sysdeps/unix/sysv/linux/alpha/glob.c
++++ b/sysdeps/unix/sysv/linux/alpha/glob.c
+@@ -42,10 +42,6 @@ extern void __new_globfree (glob_t *__pglob);
+ #undef globfree64
+ 
+ versioned_symbol (libc, __new_glob, glob, GLIBC_2_1);
+-versioned_symbol (libc, __new_globfree, globfree, GLIBC_2_1);
+ libc_hidden_ver (__new_glob, glob)
+-libc_hidden_ver (__new_globfree, globfree)
+ 
+ weak_alias (__new_glob, glob64)
+-weak_alias (__new_globfree, globfree64)
+-libc_hidden_ver (__new_globfree, globfree64)
+diff --git a/sysdeps/unix/sysv/linux/alpha/globfree.c b/sysdeps/unix/sysv/linux/alpha/globfree.c
+new file mode 100644
+index 0000000000..98cf1c200b
+--- /dev/null
++++ b/sysdeps/unix/sysv/linux/alpha/globfree.c
+@@ -0,0 +1,37 @@
++/* Compat globfree.  Linux/alpha version.
++   Copyright (C) 2017 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/>.  */
++
++#define globfree64 __no_globfree64_decl
++#include <sys/types.h>
++#include <glob.h>
++#include <shlib-compat.h>
++
++#define globfree(pglob) \
++  __new_globfree (pglob)
++
++extern void __new_globfree (glob_t *__pglob);
++
++#include <posix/globfree.c>
++
++#undef globfree64
++
++versioned_symbol (libc, __new_globfree, globfree, GLIBC_2_1);
++libc_hidden_ver (__new_globfree, globfree)
++
++weak_alias (__new_globfree, globfree64)
++libc_hidden_ver (__new_globfree, globfree64)
+diff --git a/sysdeps/unix/sysv/linux/alpha/vfork.S b/sysdeps/unix/sysv/linux/alpha/vfork.S
+index 9fc199ac41..e5f7ed0661 100644
+--- a/sysdeps/unix/sysv/linux/alpha/vfork.S
++++ b/sysdeps/unix/sysv/linux/alpha/vfork.S
+@@ -25,24 +25,9 @@ ENTRY(__libc_vfork)
+ 	rduniq
+ 	mov	v0, a1
+ 
+-	/* Save the TCB-cached PID away in A2, and then negate the TCB
+-           field.  But if it's zero, set it to 0x80000000 instead.  See
+-           raise.c for the logic that relies on this value.  */
+-	ldl	a2, PID_OFFSET(v0)
+-	ldah	t0, -0x8000
+-	negl	a2, t1
+-	cmovne	a2, t1, t0
+-	stl	t0, PID_OFFSET(v0);
+-
+ 	lda	v0, SYS_ify(vfork)
+ 	call_pal PAL_callsys
+ 
+-	/* Restore the original value of the TCB cache of the PID, if we're
+-	   the parent.  But in the child (syscall return value equals zero),
+-	   leave things as they are.  */
+-	beq	v0, 1f
+-	stl	a2, PID_OFFSET(a1)
+-1:
+ 	/* Normal error check and return.  */
+ 	bne	a3, SYSCALL_ERROR_LABEL
+ 	ret
+diff --git a/sysdeps/unix/sysv/linux/arm/clone.S b/sysdeps/unix/sysv/linux/arm/clone.S
+index 7ff681804b..4c6325d088 100644
+--- a/sysdeps/unix/sysv/linux/arm/clone.S
++++ b/sysdeps/unix/sysv/linux/arm/clone.S
+@@ -70,16 +70,6 @@ PSEUDO_END (__clone)
+ 1:
+ 	.fnstart
+ 	.cantunwind
+-	tst	ip, #CLONE_VM
+-	bne	2f
+-	GET_TLS (lr)
+-	mov	r1, r0
+-	ldr	r7, =SYS_ify(getpid)
+-	swi	0x0
+-	NEGOFF_ADJ_BASE (r1, TID_OFFSET)
+-	str	r0, NEGOFF_OFF1 (r1, TID_OFFSET)
+-	str	r0, NEGOFF_OFF2 (r1, PID_OFFSET, TID_OFFSET)
+-2:
+ 	@ pick the function arg and call address off the stack and execute
+ 	ldr	r0, [sp, #4]
+ 	ldr 	ip, [sp], #8
+diff --git a/sysdeps/unix/sysv/linux/arm/setcontext.S b/sysdeps/unix/sysv/linux/arm/setcontext.S
+index 603e508858..d1f168fece 100644
+--- a/sysdeps/unix/sysv/linux/arm/setcontext.S
++++ b/sysdeps/unix/sysv/linux/arm/setcontext.S
+@@ -86,12 +86,19 @@ weak_alias(__setcontext, setcontext)
+ 
+ 	/* Called when a makecontext() context returns.  Start the
+ 	   context in R4 or fall through to exit().  */
++	/* Unwind descriptors are looked up based on PC - 2, so we have to
++	   make sure to mark the instruction preceding the __startcontext
++	   label as .cantunwind.  */
++	.fnstart
++	.cantunwind
++	nop
+ ENTRY(__startcontext)
+ 	movs    r0, r4
+ 	bne     PLTJMP(__setcontext)
+ 
+ 	@ New context was 0 - exit
+ 	b       PLTJMP(HIDDEN_JUMPTARGET(exit))
++	.fnend
+ END(__startcontext)
+ 
+ #ifdef PIC
+diff --git a/sysdeps/unix/sysv/linux/arm/vfork.S b/sysdeps/unix/sysv/linux/arm/vfork.S
+index 500f5ca4be..794372ee12 100644
+--- a/sysdeps/unix/sysv/linux/arm/vfork.S
++++ b/sysdeps/unix/sysv/linux/arm/vfork.S
+@@ -28,16 +28,6 @@
+    and the process ID of the new process to the old process.  */
+ 
+ ENTRY (__vfork)
+-	/* Save the PID value.  */
+-	GET_TLS (r2)
+-	NEGOFF_ADJ_BASE2 (r2, r0, PID_OFFSET) /* Save the TLS addr in r2.  */
+-	ldr	r3, NEGOFF_OFF1 (r2, PID_OFFSET) /* Load the saved PID.  */
+-	rsbs	r0, r3, #0		/* Negate it, and test for zero.  */
+-	/* Use 0x80000000 if it was 0.  See raise.c for how this is used.  */
+-	it	eq
+-	moveq	r0, #0x80000000
+-	str	r0, NEGOFF_OFF1 (r2, PID_OFFSET) /* Store the temp PID.  */
+-
+ 	/* The DO_CALL macro saves r7 on the stack, to enable generation
+ 	   of ARM unwind info.  Since the stack is initially shared between
+ 	   parent and child of vfork, that saved value could be corrupted.
+@@ -57,11 +47,6 @@ ENTRY (__vfork)
+ 	mov	r7, ip
+ 	cfi_restore (r7)
+ 
+-	/* Restore the old PID value in the parent.  */
+-	cmp	r0, #0		/* If we are the parent... */
+-	it	ne
+-	strne	r3, NEGOFF_OFF1 (r2, PID_OFFSET) /* restore the saved PID.  */
+-
+ 	cmn	a1, #4096
+ 	it	cc
+ 	RETINSTR(cc, lr)
+diff --git a/sysdeps/unix/sysv/linux/createthread.c b/sysdeps/unix/sysv/linux/createthread.c
+index 6d32cece48..ec86f50814 100644
+--- a/sysdeps/unix/sysv/linux/createthread.c
++++ b/sysdeps/unix/sysv/linux/createthread.c
+@@ -128,10 +128,10 @@ create_thread (struct pthread *pd, const struct pthread_attr *attr,
+ 	      /* The operation failed.  We have to kill the thread.
+ 		 We let the normal cancellation mechanism do the work.  */
+ 
++	      pid_t pid = __getpid ();
+ 	      INTERNAL_SYSCALL_DECL (err2);
+-	      (void) INTERNAL_SYSCALL (tgkill, err2, 3,
+-				       THREAD_GETMEM (THREAD_SELF, pid),
+-				       pd->tid, SIGCANCEL);
++	      (void) INTERNAL_SYSCALL_CALL (tgkill, err2, pid, pd->tid,
++					    SIGCANCEL);
+ 
+ 	      return INTERNAL_SYSCALL_ERRNO (res, err);
+ 	    }
+diff --git a/sysdeps/unix/sysv/linux/getcwd.c b/sysdeps/unix/sysv/linux/getcwd.c
+index 3f21ae743f..d0b2c38c17 100644
+--- a/sysdeps/unix/sysv/linux/getcwd.c
++++ b/sysdeps/unix/sysv/linux/getcwd.c
+@@ -76,7 +76,7 @@ __getcwd (char *buf, size_t size)
+   int retval;
+ 
+   retval = INLINE_SYSCALL (getcwd, 2, path, alloc_size);
+-  if (retval >= 0)
++  if (retval > 0 && path[0] == '/')
+     {
+ #ifndef NO_ALLOCATION
+       if (buf == NULL && size == 0)
+@@ -92,10 +92,10 @@ __getcwd (char *buf, size_t size)
+       return buf;
+     }
+ 
+-  /* The system call cannot handle paths longer than a page.
+-     Neither can the magic symlink in /proc/self.  Just use the
++  /* The system call either cannot handle paths longer than a page
++     or can succeed without returning an absolute path.  Just use the
+      generic implementation right away.  */
+-  if (errno == ENAMETOOLONG)
++  if (retval >= 0 || errno == ENAMETOOLONG)
+     {
+ #ifndef NO_ALLOCATION
+       if (buf == NULL && size == 0)
+diff --git a/sysdeps/unix/sysv/linux/getpid.c b/sysdeps/unix/sysv/linux/getpid.c
+deleted file mode 100644
+index 1124549326..0000000000
+--- a/sysdeps/unix/sysv/linux/getpid.c
++++ /dev/null
+@@ -1,64 +0,0 @@
+-/* Copyright (C) 2003-2016 Free Software Foundation, Inc.
+-   This file is part of the GNU C Library.
+-   Contributed by Ulrich Drepper <drepper@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/>.  */
+-
+-#include <unistd.h>
+-#include <tls.h>
+-#include <sysdep.h>
+-
+-
+-#if IS_IN (libc)
+-static inline __attribute__((always_inline)) pid_t really_getpid (pid_t oldval);
+-
+-static inline __attribute__((always_inline)) pid_t
+-really_getpid (pid_t oldval)
+-{
+-  if (__glibc_likely (oldval == 0))
+-    {
+-      pid_t selftid = THREAD_GETMEM (THREAD_SELF, tid);
+-      if (__glibc_likely (selftid != 0))
+-	return selftid;
+-    }
+-
+-  INTERNAL_SYSCALL_DECL (err);
+-  pid_t result = INTERNAL_SYSCALL (getpid, err, 0);
+-
+-  /* We do not set the PID field in the TID here since we might be
+-     called from a signal handler while the thread executes fork.  */
+-  if (oldval == 0)
+-    THREAD_SETMEM (THREAD_SELF, tid, result);
+-  return result;
+-}
+-#endif
+-
+-pid_t
+-__getpid (void)
+-{
+-#if !IS_IN (libc)
+-  INTERNAL_SYSCALL_DECL (err);
+-  pid_t result = INTERNAL_SYSCALL (getpid, err, 0);
+-#else
+-  pid_t result = THREAD_GETMEM (THREAD_SELF, pid);
+-  if (__glibc_unlikely (result <= 0))
+-    result = really_getpid (result);
+-#endif
+-  return result;
+-}
+-
+-libc_hidden_def (__getpid)
+-weak_alias (__getpid, getpid)
+-libc_hidden_def (getpid)
+diff --git a/sysdeps/unix/sysv/linux/hppa/clone.S b/sysdeps/unix/sysv/linux/hppa/clone.S
+index 3d037f1430..25fcd497f7 100644
+--- a/sysdeps/unix/sysv/linux/hppa/clone.S
++++ b/sysdeps/unix/sysv/linux/hppa/clone.S
+@@ -132,18 +132,6 @@ ENTRY(__clone)
+ 	ldwm	-64(%sp), %r4
+ 
+ .LthreadStart:
+-# define CLONE_VM_BIT		23	/* 0x00000100  */
+-	/* Load original clone flags.
+-	   If CLONE_VM was passed, don't modify PID/TID.
+-	   Otherwise store the result of getpid to PID/TID.  */
+-	ldw	-56(%sp), %r26
+-	bb,<,n	%r26, CLONE_VM_BIT, 1f
+-	ble     0x100(%sr2, %r0)
+-	ldi	__NR_getpid, %r20
+-	mfctl	%cr27, %r26
+-	stw	%ret0, PID_THREAD_OFFSET(%r26)
+-	stw	%ret0, TID_THREAD_OFFSET(%r26)
+-1:
+ 	/* Load up the arguments.  */
+ 	ldw	-60(%sp), %arg0
+ 	ldw     -64(%sp), %r22
+diff --git a/sysdeps/unix/sysv/linux/hppa/pt-vfork.S b/sysdeps/unix/sysv/linux/hppa/pt-vfork.S
+index df532362d2..4684048502 100644
+--- a/sysdeps/unix/sysv/linux/hppa/pt-vfork.S
++++ b/sysdeps/unix/sysv/linux/hppa/pt-vfork.S
+@@ -25,26 +25,6 @@
+    replaced by a call to `execve'.  Return -1 for errors, 0 to the new process,
+    and the process ID of the new process to the old process.  */
+ 
+-/* Load the thread register.
+-   Load the saved PID value.
+-   Negate the value.
+-   Store the temporary PID. */
+-#define SAVE_PID							\
+-	mfctl %cr27, %r26				ASM_LINE_SEP	\
+-	ldw PID_THREAD_OFFSET(%r26),%r1			ASM_LINE_SEP    \
+-	sub %r0,%r1,%r1					ASM_LINE_SEP    \
+-	stw %r1,PID_THREAD_OFFSET(%r26)			ASM_LINE_SEP
+-/* If we are the parent...
+-   Get the thread pointer.
+-   Load the saved PID.
+-   Negate the value (got back original)
+-   Restore the PID. */
+-#define RESTORE_PID							\
+-	cmpb,=,n %r0,%ret0,.Lthread_start		ASM_LINE_SEP	\
+-	mfctl %cr27, %r26				ASM_LINE_SEP	\
+-	ldw PID_THREAD_OFFSET(%r26),%r1			ASM_LINE_SEP	\
+-	sub %r0,%r1,%r1					ASM_LINE_SEP	\
+-	stw %r1,PID_THREAD_OFFSET(%r26)			ASM_LINE_SEP	\
+ .Lthread_start:						ASM_LINE_SEP
+ 
+ 	/* r26, r25, r24, r23 are free since vfork has no arguments */
+@@ -58,16 +38,10 @@ ENTRY(__vfork)
+ 	copy	%r19, %r25	/* parent */
+ #endif
+ 
+-	/* Save the process PID */
+-	SAVE_PID
+-
+ 	/* Syscall saves and restores all register states */
+ 	ble	0x100(%sr2,%r0)
+ 	ldi	__NR_vfork,%r20
+ 
+-	/* Conditionally restore the PID */
+-	RESTORE_PID
+-
+ 	/* Check for error */
+ 	ldi	-4096,%r1
+ 	comclr,>>= %r1,%ret0,%r0        /* Note: unsigned compare. */
+diff --git a/sysdeps/unix/sysv/linux/i386/Makefile b/sysdeps/unix/sysv/linux/i386/Makefile
+index 71ba61e9d7..6073a9fe04 100644
+--- a/sysdeps/unix/sysv/linux/i386/Makefile
++++ b/sysdeps/unix/sysv/linux/i386/Makefile
+@@ -31,6 +31,7 @@ endif
+ # libpthread uses six-argument inline syscalls.
+ ifeq ($(subdir),nptl)
+ libpthread-sysdep_routines += libc-do-syscall
++libpthread-shared-only-routines += libc-do-syscall
+ endif
+ 
+ ifeq ($(subdir),resource)
+@@ -48,9 +49,11 @@ endif
+ ifeq ($(subdir),nptl)
+ # pull in __syscall_error routine
+ libpthread-routines += sysdep
++libpthread-shared-only-routines += sysdep
+ endif
+ 
+ ifeq ($(subdir),rt)
+ # pull in __syscall_error routine
+ librt-routines += sysdep
++librt-shared-only-routines += sysdep
+ endif
+diff --git a/sysdeps/unix/sysv/linux/i386/clone.S b/sysdeps/unix/sysv/linux/i386/clone.S
+index 25f2a9c340..feae504ce6 100644
+--- a/sysdeps/unix/sysv/linux/i386/clone.S
++++ b/sysdeps/unix/sysv/linux/i386/clone.S
+@@ -107,9 +107,6 @@ L(thread_start):
+ 	cfi_undefined (eip);
+ 	/* Note: %esi is zero.  */
+ 	movl	%esi,%ebp	/* terminate the stack frame */
+-	testl	$CLONE_VM, %edi
+-	je	L(newpid)
+-L(haspid):
+ 	call	*%ebx
+ #ifdef PIC
+ 	call	L(here)
+@@ -121,18 +118,6 @@ L(here):
+ 	movl	$SYS_ify(exit), %eax
+ 	ENTER_KERNEL
+ 
+-	.subsection 2
+-L(newpid):
+-	movl	$SYS_ify(getpid), %eax
+-	ENTER_KERNEL
+-L(nomoregetpid):
+-	movl	%eax, %gs:PID
+-	movl	%eax, %gs:TID
+-	jmp	L(haspid)
+-	.previous
+-	cfi_endproc;
+-
+-	cfi_startproc
+ PSEUDO_END (__clone)
+ 
+ libc_hidden_def (__clone)
+diff --git a/sysdeps/unix/sysv/linux/i386/glob64.c b/sysdeps/unix/sysv/linux/i386/glob64.c
+index 802c957d6c..c2cc85741f 100644
+--- a/sysdeps/unix/sysv/linux/i386/glob64.c
++++ b/sysdeps/unix/sysv/linux/i386/glob64.c
+@@ -19,6 +19,7 @@
+ #include <dirent.h>
+ #include <glob.h>
+ #include <sys/stat.h>
++#include <shlib-compat.h>
+ 
+ #define dirent dirent64
+ #define __readdir(dirp) __readdir64 (dirp)
+@@ -33,44 +34,9 @@
+ #undef __stat
+ #define __stat(file, buf) __xstat64 (_STAT_VER, file, buf)
+ 
+-#define NO_GLOB_PATTERN_P 1
+-
+ #define COMPILE_GLOB64	1
+ 
+ #include <posix/glob.c>
+ 
+-#include "shlib-compat.h"
+-
+-libc_hidden_def (globfree64)
+-
+ versioned_symbol (libc, __glob64, glob64, GLIBC_2_2);
+ libc_hidden_ver (__glob64, glob64)
+-
+-#if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2)
+-
+-#include <sysdeps/unix/sysv/linux/i386/olddirent.h>
+-
+-int __old_glob64 (const char *__pattern, int __flags,
+-		  int (*__errfunc) (const char *, int),
+-		  glob64_t *__pglob);
+-
+-#undef dirent
+-#define dirent __old_dirent64
+-#undef GL_READDIR
+-# define GL_READDIR(pglob, stream) \
+-  ((struct __old_dirent64 *) (pglob)->gl_readdir (stream))
+-#undef __readdir
+-#define __readdir(dirp) __old_readdir64 (dirp)
+-#undef glob
+-#define glob(pattern, flags, errfunc, pglob) \
+-  __old_glob64 (pattern, flags, errfunc, pglob)
+-#define convert_dirent __old_convert_dirent
+-#define glob_in_dir __old_glob_in_dir
+-#define GLOB_ATTRIBUTE attribute_compat_text_section
+-
+-#define GLOB_ONLY_P 1
+-
+-#include <posix/glob.c>
+-
+-compat_symbol (libc, __old_glob64, glob64, GLIBC_2_1);
+-#endif
+diff --git a/sysdeps/unix/sysv/linux/i386/vfork.S b/sysdeps/unix/sysv/linux/i386/vfork.S
+index 7a1d3373bb..a865de2201 100644
+--- a/sysdeps/unix/sysv/linux/i386/vfork.S
++++ b/sysdeps/unix/sysv/linux/i386/vfork.S
+@@ -34,17 +34,6 @@ ENTRY (__vfork)
+ 	cfi_adjust_cfa_offset (-4)
+ 	cfi_register (%eip, %ecx)
+ 
+-	/* Save the TCB-cached PID away in %edx, and then negate the TCB
+-           field.  But if it's zero, set it to 0x80000000 instead.  See
+-           raise.c for the logic that relies on this value.  */
+-	movl	%gs:PID, %edx
+-	movl	%edx, %eax
+-	negl	%eax
+-	jne	1f
+-	movl	$0x80000000, %eax
+-1:	movl	%eax, %gs:PID
+-
+-
+ 	/* Stuff the syscall number in EAX and enter into the kernel.  */
+ 	movl	$SYS_ify (vfork), %eax
+ 	int	$0x80
+@@ -55,14 +44,6 @@ ENTRY (__vfork)
+ 	pushl	%ecx
+ 	cfi_adjust_cfa_offset (4)
+ 
+-	/* Restore the original value of the TCB cache of the PID, if we're
+-	   the parent.  But in the child (syscall return value equals zero),
+-	   leave things as they are.  */
+-	testl	%eax, %eax
+-	je	1f
+-	movl	%edx, %gs:PID
+-1:
+-
+ 	cmpl	$-4095, %eax
+ 	/* Branch forward if it failed.  */
+ 	jae	SYSCALL_ERROR_LABEL
+diff --git a/sysdeps/unix/sysv/linux/ia64/Makefile b/sysdeps/unix/sysv/linux/ia64/Makefile
+index 1de62c528a..4d6766db5e 100644
+--- a/sysdeps/unix/sysv/linux/ia64/Makefile
++++ b/sysdeps/unix/sysv/linux/ia64/Makefile
+@@ -19,6 +19,7 @@ endif
+ 
+ ifeq ($(subdir),rt)
+ librt-routines += rt-sysdep
++librt-shared-only-routines += rt-sysdep
+ endif
+ 
+ ifeq ($(subdir),nptl)
+diff --git a/sysdeps/unix/sysv/linux/ia64/clone2.S b/sysdeps/unix/sysv/linux/ia64/clone2.S
+index b4cfdfc959..e637b6d4a5 100644
+--- a/sysdeps/unix/sysv/linux/ia64/clone2.S
++++ b/sysdeps/unix/sysv/linux/ia64/clone2.S
+@@ -67,19 +67,7 @@ ENTRY(__clone2)
+ (CHILD)	mov loc0=gp
+ (PARENT) ret
+ 	;;
+-	tbit.nz p6,p0=in3,8	/* CLONE_VM */
+-(p6)	br.cond.dptk 1f
+-	;;
+-	mov r15=SYS_ify (getpid)
+-(p7)	break __BREAK_SYSCALL
+-	;;
+-	add r9=PID,r13
+-	add r10=TID,r13
+-	;;
+-	st4 [r9]=r8
+-	st4 [r10]=r8
+-	;;
+-1:	ld8 out1=[in0],8	/* Retrieve code pointer.	*/
++	ld8 out1=[in0],8	/* Retrieve code pointer.	*/
+ 	mov out0=in4		/* Pass proper argument	to fn */
+ 	;;
+ 	ld8 gp=[in0]		/* Load function gp.		*/
+diff --git a/sysdeps/unix/sysv/linux/ia64/vfork.S b/sysdeps/unix/sysv/linux/ia64/vfork.S
+index 9154d7c0fd..84bfdd5d8a 100644
+--- a/sysdeps/unix/sysv/linux/ia64/vfork.S
++++ b/sysdeps/unix/sysv/linux/ia64/vfork.S
+@@ -33,32 +33,12 @@ ENTRY (__libc_vfork)
+ 	.prologue	// work around a GAS bug which triggers if
+ 	.body		// first .prologue is not at the beginning of proc.
+ 	alloc r2=ar.pfs,0,0,2,0
+-	adds r14=PID,r13
+-	;;
+-	ld4 r16=[r14]
+-	;;
+-	sub r15=0,r16
+-	cmp.eq p6,p0=0,r16
+-	;;
+-(p6)	movl r15=0x80000000
+ 	mov out0=CLONE_VM+CLONE_VFORK+SIGCHLD
+ 	mov out1=0		/* Standard sp value.			*/
+ 	;;
+-	st4 [r14]=r15
+ 	DO_CALL (SYS_ify (clone))
+ 	cmp.eq p6,p0=0,r8
+-	adds r14=PID,r13
+ (p6)	br.cond.dptk 1f
+-	;;
+-	ld4 r15=[r14]
+-	;;
+-	extr.u r16=r15,0,31
+-	;;
+-	cmp.eq p0,p6=0,r16
+-	;;
+-(p6)	sub r16=0,r15
+-	;;
+-	st4 [r14]=r16
+ 1:
+ 	cmp.eq p6,p0=-1,r10
+ (p6)	br.cond.spnt.few __syscall_error
+diff --git a/sysdeps/unix/sysv/linux/m68k/clone.S b/sysdeps/unix/sysv/linux/m68k/clone.S
+index 3a828443dc..630a29209d 100644
+--- a/sysdeps/unix/sysv/linux/m68k/clone.S
++++ b/sysdeps/unix/sysv/linux/m68k/clone.S
+@@ -98,19 +98,6 @@ ENTRY (__clone)
+ 	cfi_startproc
+ 	cfi_undefined (pc)	/* Mark end of stack */
+ 	subl	%fp, %fp	/* terminate the stack frame */
+-	/* Check and see if we need to reset the PID.  */
+-	andl	#CLONE_VM, %d1
+-	jne	1f
+-	movel	#SYS_ify (getpid), %d0
+-	trap	#0
+-	movel	%a0, -(%sp)
+-	movel	%d0, -(%sp)
+-	bsrl	__m68k_read_tp@PLTPC
+-	movel	(%sp)+, %d0
+-	movel	%d0, PID_OFFSET(%a0)
+-	movel	%d0, TID_OFFSET(%a0)
+-	movel	(%sp)+, %a0
+-1:
+ 	jsr	(%a0)
+ 	movel	%d0, %d1
+ 	movel	#SYS_ify (exit), %d0
+diff --git a/sysdeps/unix/sysv/linux/m68k/vfork.S b/sysdeps/unix/sysv/linux/m68k/vfork.S
+index 1625a7b7a0..e27479361b 100644
+--- a/sysdeps/unix/sysv/linux/m68k/vfork.S
++++ b/sysdeps/unix/sysv/linux/m68k/vfork.S
+@@ -28,18 +28,6 @@
+ 
+ ENTRY (__vfork)
+ 
+-	/* Save the TCB-cached PID away in %d1, and then negate the TCB
+-	   field.  But if it's zero, set it to 0x80000000 instead.  See
+-	   raise.c for the logic that relies on this value.  */
+-	jbsr	__m68k_read_tp@PLTPC
+-	movel	%a0, %a1
+-	movel	PID_OFFSET(%a1), %d0
+-	movel	%d0, %d1
+-	negl	%d0
+-	jne	1f
+-	movel	#0x80000000, %d0
+-1:	movel	%d0, PID_OFFSET(%a1)
+-
+ 	/* Pop the return PC value into A0.  */
+ 	movel	%sp@+, %a0
+ 	cfi_adjust_cfa_offset (-4)
+@@ -49,14 +37,6 @@ ENTRY (__vfork)
+ 	movel	#SYS_ify (vfork), %d0
+ 	trap	#0
+ 
+-	/* Restore the original value of the TCB cache of the PID, if we're
+-	   the parent.  But in the child (syscall return value equals zero),
+-	   leave things as they are.  */
+-	tstl	%d0
+-	jeq	1f
+-	movel	%d1, PID_OFFSET(%a1)
+-1:
+-
+ 	tstl	%d0
+ 	jmi	.Lerror		/* Branch forward if it failed.  */
+ 
+diff --git a/sysdeps/unix/sysv/linux/microblaze/Makefile b/sysdeps/unix/sysv/linux/microblaze/Makefile
+index 44a838fa11..d178bc6f34 100644
+--- a/sysdeps/unix/sysv/linux/microblaze/Makefile
++++ b/sysdeps/unix/sysv/linux/microblaze/Makefile
+@@ -5,4 +5,5 @@ endif
+ ifeq ($(subdir),nptl)
+ # pull in __syscall_error routine
+ libpthread-routines += sysdep
+-endif
+\ No newline at end of file
++libpthread-shared-only-routines += sysdep
++endif
+diff --git a/sysdeps/unix/sysv/linux/mips/clone.S b/sysdeps/unix/sysv/linux/mips/clone.S
+index 39634c5cf0..7ae65ef723 100644
+--- a/sysdeps/unix/sysv/linux/mips/clone.S
++++ b/sysdeps/unix/sysv/linux/mips/clone.S
+@@ -130,11 +130,6 @@ L(thread_start):
+ 	SAVE_GP (GPOFF)
+ 	/* The stackframe has been created on entry of clone().  */
+ 
+-	/* Check and see if we need to reset the PID.  */
+-	and	a1,a0,CLONE_VM
+-	beqz	a1,L(restore_pid)
+-L(donepid):
+-
+ 	/* Restore the arg for user's function.  */
+ 	PTR_L		t9,0(sp)	/* Function pointer.  */
+ 	PTR_L		a0,PTRSIZE(sp)	/* Argument pointer.  */
+@@ -151,14 +146,6 @@ L(donepid):
+ 	jal		_exit
+ #endif
+ 
+-L(restore_pid):
+-	li		v0,__NR_getpid
+-	syscall
+-	READ_THREAD_POINTER(v1)
+-	INT_S		v0,PID_OFFSET(v1)
+-	INT_S		v0,TID_OFFSET(v1)
+-	b		L(donepid)
+-
+ 	END(__thread_start)
+ 
+ libc_hidden_def (__clone)
+diff --git a/sysdeps/unix/sysv/linux/mips/mips64/n64/globfree64.c b/sysdeps/unix/sysv/linux/mips/mips64/n64/globfree64.c
+new file mode 100644
+index 0000000000..abc35fdd2b
+--- /dev/null
++++ b/sysdeps/unix/sysv/linux/mips/mips64/n64/globfree64.c
+@@ -0,0 +1 @@
++/* glob64 is in globfree64.c */
+diff --git a/sysdeps/unix/sysv/linux/mips/mips64/n64/syscalls.list b/sysdeps/unix/sysv/linux/mips/mips64/n64/syscalls.list
+index 890a74494a..26ab6d0b75 100644
+--- a/sysdeps/unix/sysv/linux/mips/mips64/n64/syscalls.list
++++ b/sysdeps/unix/sysv/linux/mips/mips64/n64/syscalls.list
+@@ -4,6 +4,8 @@ mmap		-	mmap		b:aniiii __mmap		mmap __mmap64 mmap64
+ 
+ sync_file_range	-	sync_file_range	Ci:iiii	sync_file_range
+ 
++readahead	-	readahead	i:iii	__readahead	readahead
++
+ prlimit		EXTRA	prlimit64	i:iipp	prlimit		prlimit64
+ 
+ fanotify_mark	EXTRA	fanotify_mark	i:iiiis	fanotify_mark
+diff --git a/sysdeps/unix/sysv/linux/mips/vfork.S b/sysdeps/unix/sysv/linux/mips/vfork.S
+index 1867c8626e..0b9244b7f8 100644
+--- a/sysdeps/unix/sysv/linux/mips/vfork.S
++++ b/sysdeps/unix/sysv/linux/mips/vfork.S
+@@ -60,14 +60,6 @@ NESTED(__libc_vfork,FRAMESZ,sp)
+ 	PTR_ADDU	sp, FRAMESZ
+ 	cfi_adjust_cfa_offset (-FRAMESZ)
+ 
+-	/* Save the PID value.  */
+-	READ_THREAD_POINTER(v1)	   /* Get the thread pointer.  */
+-	lw	a2, PID_OFFSET(v1) /* Load the saved PID.  */
+-	subu	a2, $0, a2	   /* Negate it.  */
+-	bnez	a2, 1f		   /* If it was zero... */
+-	lui	a2, 0x8000	   /* use 0x80000000 instead.  */
+-1:	sw	a2, PID_OFFSET(v1) /* Store the temporary PID.  */
+-
+ 	li		a0, 0x4112	/* CLONE_VM | CLONE_VFORK | SIGCHLD */
+ 	move		a1, sp
+ 
+@@ -75,17 +67,6 @@ NESTED(__libc_vfork,FRAMESZ,sp)
+ 	li		v0,__NR_clone
+ 	syscall
+ 
+-	/* Restore the old PID value in the parent.  */
+-	beqz	v0, 1f		/* If we are the parent... */
+-	READ_THREAD_POINTER(v1)	/* Get the thread pointer.  */
+-	lw	a2, PID_OFFSET(v1) /* Load the saved PID.  */
+-	subu	a2, $0, a2	   /* Re-negate it.  */
+-	lui	a0, 0x8000	   /* Load 0x80000000... */
+-	bne	a2, a0, 2f	   /* ... compare against it... */
+-	li	a2, 0		   /* ... use 0 instead.  */
+-2:	sw	a2, PID_OFFSET(v1) /* Restore the PID.  */
+-1:
+-
+ 	cfi_remember_state
+ 	bnez		a3,L(error)
+ 
+diff --git a/sysdeps/unix/sysv/linux/nios2/clone.S b/sysdeps/unix/sysv/linux/nios2/clone.S
+index 30b6e4a6c8..c9fa00f94c 100644
+--- a/sysdeps/unix/sysv/linux/nios2/clone.S
++++ b/sysdeps/unix/sysv/linux/nios2/clone.S
+@@ -68,14 +68,6 @@ thread_start:
+ 	cfi_startproc
+ 	cfi_undefined (ra)
+ 
+-	/* We expect the argument registers to be preserved across system
+-	   calls and across task cloning, so flags should be in r4 here.  */
+-	andi	r2, r4, CLONE_VM
+-	bne	r2, zero, 2f
+-        DO_CALL (getpid, 0)
+-	stw	r2, PID_OFFSET(r23)
+-	stw	r2, TID_OFFSET(r23)
+-2:
+ 	ldw	r5, 4(sp)	/* Function pointer.  */
+ 	ldw	r4, 0(sp)	/* Argument pointer.  */
+ 	addi	sp, sp, 8
+diff --git a/sysdeps/unix/sysv/linux/nios2/vfork.S b/sysdeps/unix/sysv/linux/nios2/vfork.S
+index c1bb9c7134..8997269199 100644
+--- a/sysdeps/unix/sysv/linux/nios2/vfork.S
++++ b/sysdeps/unix/sysv/linux/nios2/vfork.S
+@@ -21,20 +21,10 @@
+ 
+ ENTRY(__vfork)
+ 
+-	ldw	r6, PID_OFFSET(r23)
+-	sub	r7, zero, r6
+-	bne	r7, zero, 2f
+-	movhi	r7, %hi(0x80000000)
+-2:
+-	stw	r7, PID_OFFSET(r23)
+-
+ 	movi	r4, 0x4111 /* (CLONE_VM | CLONE_VFORK | SIGCHLD) */
+ 	mov	r5, zero
+ 	DO_CALL (clone, 2)
+ 
+-	beq	r2, zero, 1f
+-	stw	r6, PID_OFFSET(r23)
+-1:
+ 	bne	r7, zero, SYSCALL_ERROR_LABEL
+ 	ret
+ 
+diff --git a/sysdeps/unix/sysv/linux/oldglob.c b/sysdeps/unix/sysv/linux/oldglob.c
+new file mode 100644
+index 0000000000..8233e57ce9
+--- /dev/null
++++ b/sysdeps/unix/sysv/linux/oldglob.c
+@@ -0,0 +1,42 @@
++#include <shlib-compat.h>
++
++#if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2)
++
++#include <dirent.h>
++#include <glob.h>
++#include <sys/stat.h>
++
++#include <sysdeps/unix/sysv/linux/i386/olddirent.h>
++
++int __old_glob64 (const char *__pattern, int __flags,
++		  int (*__errfunc) (const char *, int),
++		  glob64_t *__pglob);
++libc_hidden_proto (__old_glob64);
++
++#define dirent __old_dirent64
++#define GL_READDIR(pglob, stream) \
++  ((struct __old_dirent64 *) (pglob)->gl_readdir (stream))
++#undef __readdir
++#define __readdir(dirp) __old_readdir64 (dirp)
++
++#define glob_t glob64_t
++#define glob(pattern, flags, errfunc, pglob) \
++  __old_glob64 (pattern, flags, errfunc, pglob)
++#define globfree(pglob) globfree64(pglob)
++
++#define convert_dirent __old_convert_dirent
++#define glob_in_dir __old_glob_in_dir
++
++#undef stat
++#define stat stat64
++#undef __stat
++#define __stat(file, buf) __xstat64 (_STAT_VER, file, buf)
++
++#define GLOB_ATTRIBUTE attribute_compat_text_section
++
++#include <posix/glob.c>
++
++libc_hidden_def (__old_glob64);
++
++compat_symbol (libc, __old_glob64, glob64, GLIBC_2_1);
++#endif
+diff --git a/sysdeps/unix/sysv/linux/powerpc/Makefile b/sysdeps/unix/sysv/linux/powerpc/Makefile
+index c89ed9ec7d..2cfb46eca3 100644
+--- a/sysdeps/unix/sysv/linux/powerpc/Makefile
++++ b/sysdeps/unix/sysv/linux/powerpc/Makefile
+@@ -8,6 +8,7 @@ abi-64-v2-condition := __WORDSIZE == 64 && _CALL_ELF == 2
+ 
+ ifeq ($(subdir),rt)
+ librt-routines += rt-sysdep
++librt-shared-only-routines += rt-sysdep
+ endif
+ 
+ ifeq ($(subdir),stdlib)
+@@ -34,4 +35,5 @@ ifeq ($(subdir),nptl)
+ libpthread-routines += sysdep
+ libpthread-sysdep_routines += elision-lock elision-unlock elision-timed \
+ 			      elision-trylock
++libpthread-shared-only-routines += sysdep
+ endif
+diff --git a/sysdeps/unix/sysv/linux/powerpc/elision-lock.c b/sysdeps/unix/sysv/linux/powerpc/elision-lock.c
+index dd1e4c3b17..7dd3d835b6 100644
+--- a/sysdeps/unix/sysv/linux/powerpc/elision-lock.c
++++ b/sysdeps/unix/sysv/linux/powerpc/elision-lock.c
+@@ -45,7 +45,9 @@
+ int
+ __lll_lock_elision (int *lock, short *adapt_count, EXTRAARG int pshared)
+ {
+-  if (*adapt_count > 0)
++  /* adapt_count is accessed concurrently but is just a hint.  Thus,
++     use atomic accesses but relaxed MO is sufficient.  */
++  if (atomic_load_relaxed (adapt_count) > 0)
+     {
+       goto use_lock;
+     }
+@@ -67,7 +69,8 @@ __lll_lock_elision (int *lock, short *adapt_count, EXTRAARG int pshared)
+ 	  if (_TEXASRU_FAILURE_PERSISTENT (__builtin_get_texasru ()))
+ 	    {
+ 	      if (aconf.skip_lock_internal_abort > 0)
+-		*adapt_count = aconf.skip_lock_internal_abort;
++		atomic_store_relaxed (adapt_count,
++				      aconf.skip_lock_internal_abort);
+ 	      goto use_lock;
+ 	    }
+ 	}
+@@ -75,7 +78,8 @@ __lll_lock_elision (int *lock, short *adapt_count, EXTRAARG int pshared)
+ 
+   /* Fall back to locks for a bit if retries have been exhausted */
+   if (aconf.try_tbegin > 0 && aconf.skip_lock_out_of_tbegin_retries > 0)
+-    *adapt_count = aconf.skip_lock_out_of_tbegin_retries;
++    atomic_store_relaxed (adapt_count,
++			  aconf.skip_lock_out_of_tbegin_retries);
+ 
+ use_lock:
+   return LLL_LOCK ((*lock), pshared);
+diff --git a/sysdeps/unix/sysv/linux/powerpc/elision-trylock.c b/sysdeps/unix/sysv/linux/powerpc/elision-trylock.c
+index 0807a6a432..606185670d 100644
+--- a/sysdeps/unix/sysv/linux/powerpc/elision-trylock.c
++++ b/sysdeps/unix/sysv/linux/powerpc/elision-trylock.c
+@@ -34,7 +34,7 @@ __lll_trylock_elision (int *futex, short *adapt_count)
+   __libc_tabort (_ABORT_NESTED_TRYLOCK);
+ 
+   /* Only try a transaction if it's worth it.  */
+-  if (*adapt_count > 0)
++  if (atomic_load_relaxed (adapt_count) > 0)
+     {
+       goto use_lock;
+     }
+@@ -49,7 +49,7 @@ __lll_trylock_elision (int *futex, short *adapt_count)
+       __libc_tend (0);
+ 
+       if (aconf.skip_lock_busy > 0)
+-	*adapt_count = aconf.skip_lock_busy;
++	atomic_store_relaxed (adapt_count, aconf.skip_lock_busy);
+     }
+   else
+     {
+@@ -59,7 +59,8 @@ __lll_trylock_elision (int *futex, short *adapt_count)
+ 	     result in another failure.  Use normal locking now and
+ 	     for the next couple of calls.  */
+ 	  if (aconf.skip_trylock_internal_abort > 0)
+-	    *adapt_count = aconf.skip_trylock_internal_abort;
++	    atomic_store_relaxed (adapt_count,
++				aconf.skip_trylock_internal_abort);
+ 	}
+     }
+ 
+diff --git a/sysdeps/unix/sysv/linux/powerpc/elision-unlock.c b/sysdeps/unix/sysv/linux/powerpc/elision-unlock.c
+index 43c5a67df2..51d7018e4c 100644
+--- a/sysdeps/unix/sysv/linux/powerpc/elision-unlock.c
++++ b/sysdeps/unix/sysv/linux/powerpc/elision-unlock.c
+@@ -28,13 +28,16 @@ __lll_unlock_elision (int *lock, short *adapt_count, int pshared)
+     __libc_tend (0);
+   else
+     {
+-      lll_unlock ((*lock), pshared);
++      /* Update adapt_count in the critical section to prevent a
++	 write-after-destroy error as mentioned in BZ 20822.  The
++	 following update of adapt_count has to be contained within
++	 the critical region of the fall-back lock in order to not violate
++	 the mutex destruction requirements.  */
++      short __tmp = atomic_load_relaxed (adapt_count);
++      if (__tmp > 0)
++	atomic_store_relaxed (adapt_count, __tmp - 1);
+ 
+-      /* Update the adapt count AFTER completing the critical section.
+-         Doing this here prevents unneeded stalling when entering
+-         a critical section.  Saving about 8% runtime on P8.  */
+-      if (*adapt_count > 0)
+-	(*adapt_count)--;
++      lll_unlock ((*lock), pshared);
+     }
+   return 0;
+ }
+diff --git a/sysdeps/unix/sysv/linux/powerpc/powerpc32/clone.S b/sysdeps/unix/sysv/linux/powerpc/powerpc32/clone.S
+index bebadbfbb9..49fe01ecde 100644
+--- a/sysdeps/unix/sysv/linux/powerpc/powerpc32/clone.S
++++ b/sysdeps/unix/sysv/linux/powerpc/powerpc32/clone.S
+@@ -76,15 +76,6 @@ ENTRY (__clone)
+ 	crandc	cr1*4+eq,cr1*4+eq,cr0*4+so
+ 	bne-	cr1,L(parent)		/* The '-' is to minimise the race.  */
+ 
+-	/* If CLONE_VM is set do not update the pid/tid field.  */
+-	andi.	r0,r28,CLONE_VM
+-	bne+	cr0,L(oldpid)
+-
+-	DO_CALL(SYS_ify(getpid))
+-	stw	r3,TID(r2)
+-	stw	r3,PID(r2)
+-L(oldpid):
+-
+ 	/* Call procedure.  */
+ 	mtctr	r30
+ 	mr	r3,r31
+diff --git a/sysdeps/unix/sysv/linux/powerpc/powerpc32/vfork.S b/sysdeps/unix/sysv/linux/powerpc/powerpc32/vfork.S
+index edbc7de1e6..0a724953a4 100644
+--- a/sysdeps/unix/sysv/linux/powerpc/powerpc32/vfork.S
++++ b/sysdeps/unix/sysv/linux/powerpc/powerpc32/vfork.S
+@@ -27,34 +27,8 @@
+ 
+ ENTRY (__vfork)
+ 
+-	/* Load the TCB-cached PID value and negates it. If It it is zero
+-	   sets it to 0x800000.  And then sets its value again on TCB field.
+-	   See raise.c for the logic that relies on this value.  */
+-
+-	lwz	r0,PID(r2)
+-	cmpwi	cr0,r0,0
+-	neg	r0,r0
+-	bne-	cr0,1f
+-	lis	r0,0x8000
+-1:	stw	r0,PID(r2)
+-
+ 	DO_CALL (SYS_ify (vfork))
+ 
+-	cmpwi	cr1,r3,0
+-	beqlr-	1
+-
+-	/* Restore the original value of the TCB cache of the PID, if we're
+-	   the parent.  But in the child (syscall return value equals zero),
+-	   leave things as they are.  */
+-	lwz	r0,PID(r2)
+-	/* Cannot use clrlwi. here, because cr0 needs to be preserved
+-	   until PSEUDO_RET.  */
+-	clrlwi	r4,r0,1
+-	cmpwi	cr1,r4,0
+-	beq-	cr1,1f
+-	neg	r4,r0
+-1:	stw	r4,PID(r2)
+-
+ 	PSEUDO_RET
+ 
+ PSEUDO_END (__vfork)
+diff --git a/sysdeps/unix/sysv/linux/powerpc/powerpc64/clone.S b/sysdeps/unix/sysv/linux/powerpc/powerpc64/clone.S
+index 7c59b9b4e9..d8604f6731 100644
+--- a/sysdeps/unix/sysv/linux/powerpc/powerpc64/clone.S
++++ b/sysdeps/unix/sysv/linux/powerpc/powerpc64/clone.S
+@@ -78,15 +78,6 @@ ENTRY (__clone)
+ 	crandc	cr1*4+eq,cr1*4+eq,cr0*4+so
+ 	bne-	cr1,L(parent)		/* The '-' is to minimise the race.  */
+ 
+-	/* If CLONE_VM is set do not update the pid/tid field.  */
+-	rldicl.	r0,r29,56,63		/* flags & CLONE_VM.  */
+-	bne+	cr0,L(oldpid)
+-
+-	DO_CALL(SYS_ify(getpid))
+-	stw	r3,TID(r13)
+-	stw	r3,PID(r13)
+-L(oldpid):
+-
+ 	std	r2,FRAME_TOC_SAVE(r1)
+ 	/* Call procedure.  */
+ 	PPC64_LOAD_FUNCPTR r30
+diff --git a/sysdeps/unix/sysv/linux/powerpc/powerpc64/vfork.S b/sysdeps/unix/sysv/linux/powerpc/powerpc64/vfork.S
+index 3083ab7b3c..6b4cf432c1 100644
+--- a/sysdeps/unix/sysv/linux/powerpc/powerpc64/vfork.S
++++ b/sysdeps/unix/sysv/linux/powerpc/powerpc64/vfork.S
+@@ -28,31 +28,8 @@
+ ENTRY (__vfork)
+ 	CALL_MCOUNT 0
+ 
+-	/* Load the TCB-cached PID value and negates it. If It it is zero
+-	   sets it to 0x800000.  And then sets its value again on TCB field.
+-	   See raise.c for the logic that relies on this value.  */
+-	lwz	r0,PID(r13)
+-	cmpwi	cr0,r0,0
+-	neg	r0,r0
+-	bne-	cr0,1f
+-	lis	r0,0x8000
+-1:	stw	r0,PID(r13)
+-
+ 	DO_CALL (SYS_ify (vfork))
+ 
+-	cmpwi	cr1,r3,0
+-	beqlr-	1
+-
+-	/* Restore the original value of the TCB cache of the PID, if we're
+-	   the parent.  But in the child (syscall return value equals zero),
+-	   leave things as they are.  */
+-	lwz	r0,PID(r13)
+-	clrlwi	r4,r0,1
+-	cmpwi	cr1,r4,0
+-	beq-	cr1,1f
+-	neg	r4,r0
+-1:	stw	r4,PID(r13)
+-
+ 	PSEUDO_RET
+ 
+ PSEUDO_END (__vfork)
+diff --git a/sysdeps/unix/sysv/linux/pread.c b/sysdeps/unix/sysv/linux/pread.c
+index 1bcff64781..46d974d952 100644
+--- a/sysdeps/unix/sysv/linux/pread.c
++++ b/sysdeps/unix/sysv/linux/pread.c
+@@ -28,8 +28,7 @@
+ ssize_t
+ __libc_pread (int fd, void *buf, size_t count, off_t offset)
+ {
+-  return SYSCALL_CANCEL (pread, fd, buf, count,
+-			 __ALIGNMENT_ARG SYSCALL_LL (offset));
++  return SYSCALL_CANCEL (pread, fd, buf, count, SYSCALL_LL_PRW (offset));
+ }
+ 
+ strong_alias (__libc_pread, __pread)
+diff --git a/sysdeps/unix/sysv/linux/pread64.c b/sysdeps/unix/sysv/linux/pread64.c
+index 58c6aeb541..f51beae77a 100644
+--- a/sysdeps/unix/sysv/linux/pread64.c
++++ b/sysdeps/unix/sysv/linux/pread64.c
+@@ -26,8 +26,7 @@
+ ssize_t
+ __libc_pread64 (int fd, void *buf, size_t count, off64_t offset)
+ {
+-  return SYSCALL_CANCEL (pread64, fd, buf, count,
+-			 __ALIGNMENT_ARG SYSCALL_LL64 (offset));
++  return SYSCALL_CANCEL (pread64, fd, buf, count, SYSCALL_LL64_PRW (offset));
+ }
+ 
+ weak_alias (__libc_pread64, __pread64)
+diff --git a/sysdeps/unix/sysv/linux/pthread-pids.h b/sysdeps/unix/sysv/linux/pthread-pids.h
+index d42bba03cf..618a5b1b9f 100644
+--- a/sysdeps/unix/sysv/linux/pthread-pids.h
++++ b/sysdeps/unix/sysv/linux/pthread-pids.h
+@@ -26,5 +26,5 @@ static inline void
+ __pthread_initialize_pids (struct pthread *pd)
+ {
+   INTERNAL_SYSCALL_DECL (err);
+-  pd->pid = pd->tid = INTERNAL_SYSCALL (set_tid_address, err, 1, &pd->tid);
++  pd->tid = INTERNAL_SYSCALL_CALL (set_tid_address, err, &pd->tid);
+ }
+diff --git a/sysdeps/unix/sysv/linux/pthread_kill.c b/sysdeps/unix/sysv/linux/pthread_kill.c
+index bcb3009675..cc109973cc 100644
+--- a/sysdeps/unix/sysv/linux/pthread_kill.c
++++ b/sysdeps/unix/sysv/linux/pthread_kill.c
+@@ -21,6 +21,7 @@
+ #include <pthreadP.h>
+ #include <tls.h>
+ #include <sysdep.h>
++#include <unistd.h>
+ 
+ 
+ int
+@@ -49,15 +50,9 @@ __pthread_kill (pthread_t threadid, int signo)
+   /* We have a special syscall to do the work.  */
+   INTERNAL_SYSCALL_DECL (err);
+ 
+-  /* One comment: The PID field in the TCB can temporarily be changed
+-     (in fork).  But this must not affect this code here.  Since this
+-     function would have to be called while the thread is executing
+-     fork, it would have to happen in a signal handler.  But this is
+-     no allowed, pthread_kill is not guaranteed to be async-safe.  */
+-  int val;
+-  val = INTERNAL_SYSCALL (tgkill, err, 3, THREAD_GETMEM (THREAD_SELF, pid),
+-			  tid, signo);
++  pid_t pid = __getpid ();
+ 
++  int val = INTERNAL_SYSCALL_CALL (tgkill, err, pid, tid, signo);
+   return (INTERNAL_SYSCALL_ERROR_P (val, err)
+ 	  ? INTERNAL_SYSCALL_ERRNO (val, err) : 0);
+ }
+diff --git a/sysdeps/unix/sysv/linux/pthread_sigqueue.c b/sysdeps/unix/sysv/linux/pthread_sigqueue.c
+index 7694d5467c..e393e0bd73 100644
+--- a/sysdeps/unix/sysv/linux/pthread_sigqueue.c
++++ b/sysdeps/unix/sysv/linux/pthread_sigqueue.c
+@@ -49,27 +49,22 @@ pthread_sigqueue (pthread_t threadid, int signo, const union sigval value)
+   if (signo == SIGCANCEL || signo == SIGTIMER || signo == SIGSETXID)
+     return EINVAL;
+ 
++  pid_t pid = getpid ();
++
+   /* Set up the siginfo_t structure.  */
+   siginfo_t info;
+   memset (&info, '\0', sizeof (siginfo_t));
+   info.si_signo = signo;
+   info.si_code = SI_QUEUE;
+-  info.si_pid = THREAD_GETMEM (THREAD_SELF, pid);
++  info.si_pid = pid;
+   info.si_uid = getuid ();
+   info.si_value = value;
+ 
+   /* We have a special syscall to do the work.  */
+   INTERNAL_SYSCALL_DECL (err);
+ 
+-  /* One comment: The PID field in the TCB can temporarily be changed
+-     (in fork).  But this must not affect this code here.  Since this
+-     function would have to be called while the thread is executing
+-     fork, it would have to happen in a signal handler.  But this is
+-     no allowed, pthread_sigqueue is not guaranteed to be async-safe.  */
+-  int val = INTERNAL_SYSCALL (rt_tgsigqueueinfo, err, 4,
+-			      THREAD_GETMEM (THREAD_SELF, pid),
+-			      tid, signo, &info);
+-
++  int val = INTERNAL_SYSCALL_CALL (rt_tgsigqueueinfo, err, pid, tid, signo,
++				   &info);
+   return (INTERNAL_SYSCALL_ERROR_P (val, err)
+ 	  ? INTERNAL_SYSCALL_ERRNO (val, err) : 0);
+ #else
+diff --git a/sysdeps/unix/sysv/linux/pwrite.c b/sysdeps/unix/sysv/linux/pwrite.c
+index 9c502beac1..1371df8a60 100644
+--- a/sysdeps/unix/sysv/linux/pwrite.c
++++ b/sysdeps/unix/sysv/linux/pwrite.c
+@@ -28,8 +28,7 @@
+ ssize_t
+ __libc_pwrite (int fd, const void *buf, size_t count, off_t offset)
+ {
+-  return SYSCALL_CANCEL (pwrite, fd, buf, count,
+-			 __ALIGNMENT_ARG SYSCALL_LL (offset));
++  return SYSCALL_CANCEL (pwrite, fd, buf, count, SYSCALL_LL_PRW (offset));
+ }
+ 
+ strong_alias (__libc_pwrite, __pwrite)
+diff --git a/sysdeps/unix/sysv/linux/pwrite64.c b/sysdeps/unix/sysv/linux/pwrite64.c
+index b49e6bc286..22f1f05a44 100644
+--- a/sysdeps/unix/sysv/linux/pwrite64.c
++++ b/sysdeps/unix/sysv/linux/pwrite64.c
+@@ -26,8 +26,7 @@
+ ssize_t
+ __libc_pwrite64 (int fd, const void *buf, size_t count, off64_t offset)
+ {
+-  return SYSCALL_CANCEL (pwrite64, fd, buf, count,
+-			 __ALIGNMENT_ARG SYSCALL_LL64 (offset));
++  return SYSCALL_CANCEL (pwrite64, fd, buf, count, SYSCALL_LL64_PRW (offset));
+ }
+ weak_alias (__libc_pwrite64, __pwrite64)
+ libc_hidden_weak (__pwrite64)
+diff --git a/sysdeps/unix/sysv/linux/raise.c b/sysdeps/unix/sysv/linux/raise.c
+index 470033e83d..49bb7cb0d4 100644
+--- a/sysdeps/unix/sysv/linux/raise.c
++++ b/sysdeps/unix/sysv/linux/raise.c
+@@ -26,13 +26,6 @@
+ int
+ raise (int sig)
+ {
+-  /* raise is an async-safe function so it could be called while the
+-     fork/vfork function temporarily invalidated the PID field.  To avoid
+-     relying on cached value we block all user-defined signal handler
+-     (which might call fork/vfork) and issue the getpid and gettid
+-     syscalls directly.  */
+-
+-
+   /* rt_sigprocmask may fail if:
+ 
+      1. sigsetsize != sizeof (sigset_t) (EINVAL)
+diff --git a/sysdeps/unix/sysv/linux/s390/Makefile b/sysdeps/unix/sysv/linux/s390/Makefile
+index 497ffd566c..f8ed013e9e 100644
+--- a/sysdeps/unix/sysv/linux/s390/Makefile
++++ b/sysdeps/unix/sysv/linux/s390/Makefile
+@@ -6,6 +6,7 @@ abi-64-condition := __WORDSIZE == 64
+ 
+ ifeq ($(subdir),rt)
+ librt-routines += rt-sysdep
++librt-shared-only-routines += rt-sysdep
+ endif
+ 
+ ifeq ($(subdir),stdlib)
+diff --git a/sysdeps/unix/sysv/linux/s390/s390-32/clone.S b/sysdeps/unix/sysv/linux/s390/s390-32/clone.S
+index 2f8fa0b840..b1de1480d1 100644
+--- a/sysdeps/unix/sysv/linux/s390/s390-32/clone.S
++++ b/sysdeps/unix/sysv/linux/s390/s390-32/clone.S
+@@ -54,13 +54,6 @@ error:
+ PSEUDO_END (__clone)
+ 
+ thread_start:
+-	tml	%r3,256		/* CLONE_VM == 0x00000100 */
+-	jne	1f
+-	svc	SYS_ify(getpid)
+-	ear	%r3,%a0
+-	st	%r2,PID(%r3)
+-	st	%r2,TID(%r3)
+-1:
+ 	/* fn is in gpr 1, arg in gpr 0 */
+ 	lr      %r2,%r0         /* set first parameter to void *arg */
+ 	ahi     %r15,-96        /* make room on the stack for the save area */
+diff --git a/sysdeps/unix/sysv/linux/s390/s390-32/vfork.S b/sysdeps/unix/sysv/linux/s390/s390-32/vfork.S
+index b7588ebd7c..cc60e139ba 100644
+--- a/sysdeps/unix/sysv/linux/s390/s390-32/vfork.S
++++ b/sysdeps/unix/sysv/linux/s390/s390-32/vfork.S
+@@ -28,21 +28,9 @@
+    and the process ID of the new process to the old process.  */
+ 
+ ENTRY (__libc_vfork)
+-	ear	%r4,%a0
+-	lhi	%r1,1
+-	icm	%r3,15,PID(%r4)
+-	sll	%r1,31
+-	je	1f
+-	lcr	%r1,%r3
+-1:	st	%r1,PID(%r4)
+-
+ 	/* Do vfork system call.  */
+ 	svc	SYS_ify (vfork)
+ 
+-	ltr	%r2,%r2
+-	je	1f
+-	st	%r3,PID(%r4)
+-1:
+ 	/* Check for error.  */
+ 	lhi	%r4,-4095
+ 	clr	%r2,%r4
+diff --git a/sysdeps/unix/sysv/linux/s390/s390-64/clone.S b/sysdeps/unix/sysv/linux/s390/s390-64/clone.S
+index fb816922ca..29606acf03 100644
+--- a/sysdeps/unix/sysv/linux/s390/s390-64/clone.S
++++ b/sysdeps/unix/sysv/linux/s390/s390-64/clone.S
+@@ -55,15 +55,6 @@ error:
+ PSEUDO_END (__clone)
+ 
+ thread_start:
+-	tmll	%r3,256		/* CLONE_VM == 0x00000100 */
+-	jne	1f
+-	svc	SYS_ify(getpid)
+-	ear	%r3,%a0
+-	sllg	%r3,%r3,32
+-	ear	%r3,%a1
+-	st	%r2,PID(%r3)
+-	st	%r2,TID(%r3)
+-1:
+ 	/* fn is in gpr 1, arg in gpr 0 */
+ 	lgr	%r2,%r0		/* set first parameter to void *arg */
+ 	aghi	%r15,-160	/* make room on the stack for the save area */
+diff --git a/sysdeps/unix/sysv/linux/s390/s390-64/vfork.S b/sysdeps/unix/sysv/linux/s390/s390-64/vfork.S
+index 0bd2161381..b9a813f2cc 100644
+--- a/sysdeps/unix/sysv/linux/s390/s390-64/vfork.S
++++ b/sysdeps/unix/sysv/linux/s390/s390-64/vfork.S
+@@ -28,22 +28,9 @@
+    and the process ID of the new process to the old process.  */
+ 
+ ENTRY (__libc_vfork)
+-	ear	%r4,%a0
+-	sllg	%r4,%r4,32
+-	ear	%r4,%a1
+-	icm	%r3,15,PID(%r4)
+-	llilh	%r1,32768
+-	je	1f
+-	lcr	%r1,%r3
+-1:	st	%r1,PID(%r4)
+-
+ 	/* Do vfork system call.  */
+ 	svc	SYS_ify (vfork)
+ 
+-	ltgr	%r2,%r2
+-	je	1f
+-	st	%r3,PID(%r4)
+-1:
+ 	/* Check for error.  */
+ 	lghi	%r4,-4095
+ 	clgr	%r2,%r4
+diff --git a/sysdeps/unix/sysv/linux/sh/clone.S b/sysdeps/unix/sysv/linux/sh/clone.S
+index 4cd7df117c..ce7cddcb19 100644
+--- a/sysdeps/unix/sysv/linux/sh/clone.S
++++ b/sysdeps/unix/sysv/linux/sh/clone.S
+@@ -66,23 +66,7 @@ ENTRY(__clone)
+ 2:
+ 	/* terminate the stack frame */
+ 	mov	#0, r14
+-	mov	r4, r0
+-	shlr8	r0
+-	tst	#1, r0			// CLONE_VM = (1 << 8)
+-	bf/s	4f
+-	 mov	r4, r0
+-	/* new pid */
+-	mov	#+SYS_ify(getpid), r3
+-	trapa	#0x15
+-3:
+-	stc	gbr, r1
+-	mov.w	.Lpidoff, r2
+-	add	r1, r2
+-	mov.l	r0, @r2
+-	mov.w	.Ltidoff, r2
+-	add	r1, r2
+-	mov.l	r0, @r2
+-4:
++
+ 	/* thread starts */
+ 	mov.l	@r15, r1
+ 	jsr	@r1
+@@ -113,10 +97,6 @@ ENTRY(__clone)
+ 	.long	_GLOBAL_OFFSET_TABLE_
+ .L3:
+ 	.long	PLTJMP(C_SYMBOL_NAME(_exit))
+-.Lpidoff:
+-	.word	PID - TLS_PRE_TCB_SIZE
+-.Ltidoff:
+-	.word	TID - TLS_PRE_TCB_SIZE
+ PSEUDO_END (__clone)
+ 
+ libc_hidden_def (__clone)
+diff --git a/sysdeps/unix/sysv/linux/sh/kernel-features.h b/sysdeps/unix/sysv/linux/sh/kernel-features.h
+index ad05fc39e1..c5240fafbd 100644
+--- a/sysdeps/unix/sysv/linux/sh/kernel-features.h
++++ b/sysdeps/unix/sysv/linux/sh/kernel-features.h
+@@ -44,3 +44,8 @@
+ 
+ /* SH does not have a 64-bit inode field.  */
+ #undef __ASSUME_ST_INO_64_BIT
++
++/* SH4 ABI does not really require argument alignment for 64-bits, but
++   the kernel interface for p{read,write}64 adds a dummy long argument
++   before the offset.  */
++#define __ASSUME_PRW_DUMMY_ARG	1
+diff --git a/sysdeps/unix/sysv/linux/sh/pwrite.c b/sysdeps/unix/sysv/linux/sh/pwrite.c
+deleted file mode 100644
+index 391ed5e17b..0000000000
+--- a/sysdeps/unix/sysv/linux/sh/pwrite.c
++++ /dev/null
+@@ -1,23 +0,0 @@
+-/* Copyright (C) 1997-2016 Free Software Foundation, Inc.
+-   This file is part of the GNU C Library.
+-   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+-
+-   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/>.  */
+-
+-/* SH4 ABI does not really require argument alignment for 64-bits, but
+-   the kernel interface for pwrite adds a dummy long argument before the
+-   offset.  */
+-#define __ALIGNMENT_ARG
+-#include <sysdeps/unix/sysv/linux/pwrite.c>
+diff --git a/sysdeps/unix/sysv/linux/sh/sh3/ucontext_i.sym b/sysdeps/unix/sysv/linux/sh/sh3/ucontext_i.sym
+index 17397c5511..25f914a93b 100644
+--- a/sysdeps/unix/sysv/linux/sh/sh3/ucontext_i.sym
++++ b/sysdeps/unix/sysv/linux/sh/sh3/ucontext_i.sym
+@@ -13,22 +13,22 @@ SIG_SETMASK
+ oLINK		ucontext (uc_link)
+ oSS_SP		ucontext (uc_stack.ss_sp)
+ oSS_SIZE	ucontext (uc_stack.ss_size)
+-oR0		mcontext (gregs[R0])
+-oR1		mcontext (gregs[R1])
+-oR2		mcontext (gregs[R2])
+-oR3		mcontext (gregs[R3])
+-oR4		mcontext (gregs[R4])
+-oR5		mcontext (gregs[R5])
+-oR6		mcontext (gregs[R6])
+-oR7		mcontext (gregs[R7])
+-oR8		mcontext (gregs[R8])
+-oR9		mcontext (gregs[R9])
+-oR10		mcontext (gregs[R10])
+-oR11		mcontext (gregs[R11])
+-oR12		mcontext (gregs[R12])
+-oR13		mcontext (gregs[R13])
+-oR14		mcontext (gregs[R14])
+-oR15		mcontext (gregs[R15])
++oR0		mcontext (gregs[REG_R0])
++oR1		mcontext (gregs[REG_R1])
++oR2		mcontext (gregs[REG_R2])
++oR3		mcontext (gregs[REG_R3])
++oR4		mcontext (gregs[REG_R4])
++oR5		mcontext (gregs[REG_R5])
++oR6		mcontext (gregs[REG_R6])
++oR7		mcontext (gregs[REG_R7])
++oR8		mcontext (gregs[REG_R8])
++oR9		mcontext (gregs[REG_R9])
++oR10		mcontext (gregs[REG_R10])
++oR11		mcontext (gregs[REG_R11])
++oR12		mcontext (gregs[REG_R12])
++oR13		mcontext (gregs[REG_R13])
++oR14		mcontext (gregs[REG_R14])
++oR15		mcontext (gregs[REG_R15])
+ oPC		mcontext (pc)
+ oPR		mcontext (pr)
+ oSR		mcontext (sr)
+diff --git a/sysdeps/unix/sysv/linux/sh/sh4/ucontext_i.sym b/sysdeps/unix/sysv/linux/sh/sh4/ucontext_i.sym
+index 65633fbcf4..130f60cd96 100644
+--- a/sysdeps/unix/sysv/linux/sh/sh4/ucontext_i.sym
++++ b/sysdeps/unix/sysv/linux/sh/sh4/ucontext_i.sym
+@@ -13,22 +13,22 @@ SIG_SETMASK
+ oLINK		ucontext (uc_link)
+ oSS_SP		ucontext (uc_stack.ss_sp)
+ oSS_SIZE	ucontext (uc_stack.ss_size)
+-oR0		mcontext (gregs[R0])
+-oR1		mcontext (gregs[R1])
+-oR2		mcontext (gregs[R2])
+-oR3		mcontext (gregs[R3])
+-oR4		mcontext (gregs[R4])
+-oR5		mcontext (gregs[R5])
+-oR6		mcontext (gregs[R6])
+-oR7		mcontext (gregs[R7])
+-oR8		mcontext (gregs[R8])
+-oR9		mcontext (gregs[R9])
+-oR10		mcontext (gregs[R10])
+-oR11		mcontext (gregs[R11])
+-oR12		mcontext (gregs[R12])
+-oR13		mcontext (gregs[R13])
+-oR14		mcontext (gregs[R14])
+-oR15		mcontext (gregs[R15])
++oR0		mcontext (gregs[REG_R0])
++oR1		mcontext (gregs[REG_R1])
++oR2		mcontext (gregs[REG_R2])
++oR3		mcontext (gregs[REG_R3])
++oR4		mcontext (gregs[REG_R4])
++oR5		mcontext (gregs[REG_R5])
++oR6		mcontext (gregs[REG_R6])
++oR7		mcontext (gregs[REG_R7])
++oR8		mcontext (gregs[REG_R8])
++oR9		mcontext (gregs[REG_R9])
++oR10		mcontext (gregs[REG_R10])
++oR11		mcontext (gregs[REG_R11])
++oR12		mcontext (gregs[REG_R12])
++oR13		mcontext (gregs[REG_R13])
++oR14		mcontext (gregs[REG_R14])
++oR15		mcontext (gregs[REG_R15])
+ oPC		mcontext (pc)
+ oPR		mcontext (pr)
+ oSR		mcontext (sr)
+diff --git a/sysdeps/unix/sysv/linux/sh/sys/ucontext.h b/sysdeps/unix/sysv/linux/sh/sys/ucontext.h
+index ab9a7e66bf..037fbb73e8 100644
+--- a/sysdeps/unix/sysv/linux/sh/sys/ucontext.h
++++ b/sysdeps/unix/sysv/linux/sh/sys/ucontext.h
+@@ -31,49 +31,47 @@
+ typedef int greg_t;
+ 
+ /* Number of general registers.  */
+-#define NGPREG	16
++#define NGREG	16
+ 
+ /* Container for all general registers.  */
+-typedef greg_t gregset_t[NGPREG];
++typedef greg_t gregset_t[NGREG];
+ 
+-#ifdef __USE_GNU
+ /* Number of each register is the `gregset_t' array.  */
+ enum
+ {
+-  R0 = 0,
+-#define R0	R0
+-  R1 = 1,
+-#define R1	R1
+-  R2 = 2,
+-#define R2	R2
+-  R3 = 3,
+-#define R3	R3
+-  R4 = 4,
+-#define R4	R4
+-  R5 = 5,
+-#define R5	R5
+-  R6 = 6,
+-#define R6	R6
+-  R7 = 7,
+-#define R7	R7
+-  R8 = 8,
+-#define R8	R8
+-  R9 = 9,
+-#define R9	R9
+-  R10 = 10,
+-#define R10	R10
+-  R11 = 11,
+-#define R11	R11
+-  R12 = 12,
+-#define R12	R12
+-  R13 = 13,
+-#define R13	R13
+-  R14 = 14,
+-#define R14	R14
+-  R15 = 15,
+-#define R15	R15
++  REG_R0 = 0,
++#define REG_R0	REG_R0
++  REG_R1 = 1,
++#define REG_R1	REG_R1
++  REG_R2 = 2,
++#define REG_R2	REG_R2
++  REG_R3 = 3,
++#define REG_R3	REG_R3
++  REG_R4 = 4,
++#define REG_R4	REG_R4
++  REG_R5 = 5,
++#define REG_R5	REG_R5
++  REG_R6 = 6,
++#define REG_R6	REG_R6
++  REG_R7 = 7,
++#define REG_R7	REG_R7
++  REG_R8 = 8,
++#define REG_R8	REG_R8
++  REG_R9 = 9,
++#define REG_R9	REG_R9
++  REG_R10 = 10,
++#define REG_R10	REG_R10
++  REG_R11 = 11,
++#define REG_R11	REG_R11
++  REG_R12 = 12,
++#define REG_R12	REG_R12
++  REG_R13 = 13,
++#define REG_R13	REG_R13
++  REG_R14 = 14,
++#define REG_R14	REG_R14
++  REG_R15 = 15,
++#define REG_R15	REG_R15
+ };
+-#endif
+ 
+ #if (defined(__SH4__) || defined(__SH4A__))
+ typedef int freg_t;
+diff --git a/sysdeps/unix/sysv/linux/sh/vfork.S b/sysdeps/unix/sysv/linux/sh/vfork.S
+index 6895bc5491..df559cb439 100644
+--- a/sysdeps/unix/sysv/linux/sh/vfork.S
++++ b/sysdeps/unix/sysv/linux/sh/vfork.S
+@@ -26,30 +26,11 @@
+    and the process ID of the new process to the old process.  */
+ 
+ ENTRY (__libc_vfork)
+-	/* Save the PID value.  */
+-	stc	gbr, r2
+-	mov.w	.L2, r0
+-	mov.l	@(r0,r2), r4
+-	neg	r4, r1
+-	tst	r1, r1
+-	bf	1f
+-	mov	#1, r1
+-	rotr	r1
+-1:
+-	mov.l	r1, @(r0,r2)
+ 
+ 	mov.w	.L1, r3
+ 	trapa	#0x10
+ 	mov     r0, r1
+ 
+-	/* Restore the old PID value in the parent.  */
+-	tst	r0, r0
+-	bt.s	2f
+-	 stc	gbr, r2
+-	mov.w	.L2, r0
+-	mov.l	r4, @(r0,r2)
+-	mov	r1, r0
+-2:
+ 	mov	#-12, r2
+ 	shad	r2, r1
+ 	not	r1, r1			// r1=0 means r0 = -1 to -4095
+@@ -61,8 +42,6 @@ ENTRY (__libc_vfork)
+ 	 nop
+ .L1:
+ 	.word	__NR_vfork
+-.L2:
+-	.word	PID - TLS_PRE_TCB_SIZE
+ 	.align	2
+ PSEUDO_END (__libc_vfork)
+ 
+diff --git a/sysdeps/unix/sysv/linux/sparc/Makefile b/sysdeps/unix/sysv/linux/sparc/Makefile
+index e67aecf8f0..a67d199eb5 100644
+--- a/sysdeps/unix/sysv/linux/sparc/Makefile
++++ b/sysdeps/unix/sysv/linux/sparc/Makefile
+@@ -6,6 +6,7 @@ abi-64-condition := __WORDSIZE == 64
+ 
+ ifeq ($(subdir),rt)
+ librt-routines += rt-sysdep
++librt-shared-only-routines += rt-sysdep
+ endif
+ 
+ ifeq ($(subdir),sysvipc)
+@@ -15,4 +16,5 @@ endif
+ ifeq ($(subdir),nptl)
+ # pull in __syscall_error routine
+ libpthread-routines += sysdep
++libpthread-shared-only-routines += sysdep
+ endif
+diff --git a/sysdeps/unix/sysv/linux/sparc/sparc32/clone.S b/sysdeps/unix/sysv/linux/sparc/sparc32/clone.S
+index d6c92f6133..0456a0d16e 100644
+--- a/sysdeps/unix/sysv/linux/sparc/sparc32/clone.S
++++ b/sysdeps/unix/sysv/linux/sparc/sparc32/clone.S
+@@ -79,13 +79,6 @@ END(__clone)
+ 
+ 	.type	__thread_start,@function
+ __thread_start:
+-	andcc	%g4, CLONE_VM, %g0
+-	bne	1f
+-	set	__NR_getpid,%g1
+-	ta	0x10
+-	st	%o0,[%g7 + PID]
+-	st	%o0,[%g7 + TID]
+-1:
+ 	mov	%g0, %fp	/* terminate backtrace */
+ 	call	%g2
+ 	 mov	%g3,%o0
+diff --git a/sysdeps/unix/sysv/linux/sparc/sparc32/vfork.S b/sysdeps/unix/sysv/linux/sparc/sparc32/vfork.S
+index 0d0a3b5298..6d985034f0 100644
+--- a/sysdeps/unix/sysv/linux/sparc/sparc32/vfork.S
++++ b/sysdeps/unix/sysv/linux/sparc/sparc32/vfork.S
+@@ -22,24 +22,14 @@
+ 	.text
+ 	.globl		__syscall_error
+ ENTRY(__libc_vfork)
+-	ld	[%g7 + PID], %o5
+-	cmp	%o5, 0
+-	bne	1f
+-	 sub	%g0, %o5, %o4
+-	sethi	%hi(0x80000000), %o4
+-1:	st	%o4, [%g7 + PID]
+-
+ 	LOADSYSCALL(vfork)
+ 	ta	0x10
+ 	bcc	2f
+ 	 mov	%o7, %g1
+-	st	%o5, [%g7 + PID]
+ 	call	__syscall_error
+ 	 mov	%g1, %o7
+ 2:	sub	%o1, 1, %o1
+ 	andcc	%o0, %o1, %o0
+-	bne,a	1f
+-	 st	%o5, [%g7 + PID]
+ 1:	retl
+ 	 nop
+ END(__libc_vfork)
+diff --git a/sysdeps/unix/sysv/linux/sparc/sparc64/clone.S b/sysdeps/unix/sysv/linux/sparc/sparc64/clone.S
+index b0f62660a7..6ffead88e2 100644
+--- a/sysdeps/unix/sysv/linux/sparc/sparc64/clone.S
++++ b/sysdeps/unix/sysv/linux/sparc/sparc64/clone.S
+@@ -76,13 +76,6 @@ END(__clone)
+ 
+ 	.type __thread_start,@function
+ __thread_start:
+-	andcc	%g4, CLONE_VM, %g0
+-	bne,pt	%icc, 1f
+-	set	__NR_getpid,%g1
+-	ta	0x6d
+-	st	%o0,[%g7 + PID]
+-	st	%o0,[%g7 + TID]
+-1:
+ 	mov	%g0, %fp	/* terminate backtrace */
+ 	call	%g2
+ 	 mov	%g3,%o0
+diff --git a/sysdeps/unix/sysv/linux/sparc/sparc64/vfork.S b/sysdeps/unix/sysv/linux/sparc/sparc64/vfork.S
+index 0818eba02e..298dd197a9 100644
+--- a/sysdeps/unix/sysv/linux/sparc/sparc64/vfork.S
++++ b/sysdeps/unix/sysv/linux/sparc/sparc64/vfork.S
+@@ -22,24 +22,14 @@
+ 	.text
+ 	.globl	__syscall_error
+ ENTRY(__libc_vfork)
+-	ld	[%g7 + PID], %o5
+-	sethi	%hi(0x80000000), %o3
+-	cmp	%o5, 0
+-	sub	%g0, %o5, %o4
+-	move	%icc, %o3, %o4
+-	st	%o4, [%g7 + PID]
+-
+ 	LOADSYSCALL(vfork)
+ 	ta	0x6d
+ 	bcc,pt	%xcc, 2f
+ 	 mov	%o7, %g1
+-	st	%o5, [%g7 + PID]
+ 	call	__syscall_error
+ 	 mov	%g1, %o7
+ 2:	sub	%o1, 1, %o1
+ 	andcc	%o0, %o1, %o0
+-	bne,a,pt %icc, 1f
+-	 st	%o5, [%g7 + PID]
+ 1:	retl
+ 	 nop
+ END(__libc_vfork)
+diff --git a/sysdeps/unix/sysv/linux/spawni.c b/sysdeps/unix/sysv/linux/spawni.c
+index bb3eecfde1..b5f20a710b 100644
+--- a/sysdeps/unix/sysv/linux/spawni.c
++++ b/sysdeps/unix/sysv/linux/spawni.c
+@@ -58,22 +58,19 @@
+    normal program exit with the exit code 127.  */
+ #define SPAWN_ERROR	127
+ 
+-/* We need to block both SIGCANCEL and SIGSETXID.  */
+-#define SIGALL_SET \
+-  ((__sigset_t) { .__val = {[0 ...  _SIGSET_NWORDS-1 ] =  -1 } })
+-
+ #ifdef __ia64__
+-# define CLONE(__fn, __stack, __stacksize, __flags, __args) \
+-  __clone2 (__fn, __stack, __stacksize, __flags, __args, 0, 0, 0)
++# define CLONE(__fn, __stackbase, __stacksize, __flags, __args) \
++  __clone2 (__fn, __stackbase, __stacksize, __flags, __args, 0, 0, 0)
+ #else
+ # define CLONE(__fn, __stack, __stacksize, __flags, __args) \
+   __clone (__fn, __stack, __flags, __args)
+ #endif
+ 
+-#if _STACK_GROWS_DOWN
+-# define STACK(__stack, __stack_size) (__stack + __stack_size)
+-#elif _STACK_GROWS_UP
++/* Since ia64 wants the stackbase w/clone2, re-use the grows-up macro.  */
++#if _STACK_GROWS_UP || defined (__ia64__)
+ # define STACK(__stack, __stack_size) (__stack)
++#elif _STACK_GROWS_DOWN
++# define STACK(__stack, __stack_size) (__stack + __stack_size)
+ #endif
+ 
+ 
+@@ -329,6 +326,11 @@ __spawnix (pid_t * pid, const char *file,
+ 
+   /* Add a slack area for child's stack.  */
+   size_t argv_size = (argc * sizeof (void *)) + 512;
++  /* We need at least a few pages in case the compiler's stack checking is
++     enabled.  In some configs, it is known to use at least 24KiB.  We use
++     32KiB to be "safe" from anything the compiler might do.  Besides, the
++     extra pages won't actually be allocated unless they get used.  */
++  argv_size += (32 * 1024);
+   size_t stack_size = ALIGN_UP (argv_size, GLRO(dl_pagesize));
+   void *stack = __mmap (NULL, stack_size, prot,
+ 			MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
+@@ -340,7 +342,9 @@ __spawnix (pid_t * pid, const char *file,
+     }
+ 
+   /* Disable asynchronous cancellation.  */
+-  int cs = LIBC_CANCEL_ASYNC ();
++  int state;
++  __libc_ptf_call (__pthread_setcancelstate,
++                   (PTHREAD_CANCEL_DISABLE, &state), 0);
+ 
+   args.file = file;
+   args.exec = exec;
+@@ -351,7 +355,7 @@ __spawnix (pid_t * pid, const char *file,
+   args.envp = envp;
+   args.xflags = xflags;
+ 
+-  __sigprocmask (SIG_BLOCK, &SIGALL_SET, &args.oldmask);
++  __libc_signal_block_all (&args.oldmask);
+ 
+   /* The clone flags used will create a new child that will run in the same
+      memory space (CLONE_VM) and the execution of calling thread will be
+@@ -384,9 +388,9 @@ __spawnix (pid_t * pid, const char *file,
+   if ((ec == 0) && (pid != NULL))
+     *pid = new_pid;
+ 
+-  __sigprocmask (SIG_SETMASK, &args.oldmask, 0);
++  __libc_signal_restore_set (&args.oldmask);
+ 
+-  LIBC_CANCEL_RESET (cs);
++  __libc_ptf_call (__pthread_setcancelstate, (state, NULL), 0);
+ 
+   return ec;
+ }
+diff --git a/sysdeps/unix/sysv/linux/syscalls.list b/sysdeps/unix/sysv/linux/syscalls.list
+index 7ae2541f8f..248641b830 100644
+--- a/sysdeps/unix/sysv/linux/syscalls.list
++++ b/sysdeps/unix/sysv/linux/syscalls.list
+@@ -18,6 +18,7 @@ execve		-	execve		i:spp	__execve	execve
+ fdatasync	-	fdatasync	Ci:i	fdatasync
+ flock		-	flock		i:ii	__flock		flock
+ get_kernel_syms	EXTRA	get_kernel_syms	i:p	__compat_get_kernel_syms	get_kernel_syms@GLIBC_2.0:GLIBC_2.23
++getpid          -       getpid          Ei:     __getpid        getpid
+ getegid		-	getegid		Ei:	__getegid	getegid
+ geteuid		-	geteuid		Ei:	__geteuid	geteuid
+ getpgid		-	getpgid		i:i	__getpgid	getpgid
+diff --git a/sysdeps/unix/sysv/linux/sysdep.h b/sysdeps/unix/sysv/linux/sysdep.h
+index a469f57121..e3ecd5638e 100644
+--- a/sysdeps/unix/sysv/linux/sysdep.h
++++ b/sysdeps/unix/sysv/linux/sysdep.h
+@@ -48,6 +48,16 @@
+   __LONG_LONG_PAIR ((long) ((val) >> 32), (long) ((val) & 0xffffffff))
+ #endif
+ 
++/* Provide a common macro to pass 64-bit value on pread and pwrite
++   syscalls.  */
++#ifdef __ASSUME_PRW_DUMMY_ARG
++# define SYSCALL_LL_PRW(val)   0, SYSCALL_LL (val)
++# define SYSCALL_LL64_PRW(val) 0, SYSCALL_LL64 (val)
++#else
++# define SYSCALL_LL_PRW(val)   __ALIGNMENT_ARG SYSCALL_LL (val)
++# define SYSCALL_LL64_PRW(val) __ALIGNMENT_ARG SYSCALL_LL64 (val)
++#endif
++
+ /* Provide a macro to pass the off{64}_t argument on p{readv,writev}{64}.  */
+ #define LO_HI_LONG(val) \
+  (long) (val), \
+diff --git a/sysdeps/unix/sysv/linux/tile/Makefile b/sysdeps/unix/sysv/linux/tile/Makefile
+index 1c1cfff280..43acea3633 100644
+--- a/sysdeps/unix/sysv/linux/tile/Makefile
++++ b/sysdeps/unix/sysv/linux/tile/Makefile
+@@ -25,4 +25,5 @@ endif
+ ifeq ($(subdir),nptl)
+ # pull in __syscall_error routine
+ libpthread-routines += sysdep
++libpthread-shared-only-routines += sysdep
+ endif
+diff --git a/sysdeps/unix/sysv/linux/tile/clone.S b/sysdeps/unix/sysv/linux/tile/clone.S
+index d1d36462e7..3f9e3d56c4 100644
+--- a/sysdeps/unix/sysv/linux/tile/clone.S
++++ b/sysdeps/unix/sysv/linux/tile/clone.S
+@@ -163,22 +163,6 @@ ENTRY (__clone)
+ .Lthread_start:
+ 	cfi_def_cfa_offset (FRAME_SIZE)
+ 	cfi_undefined (lr)
+-	/* Check and see if we need to reset the PID, which we do if
+-	   CLONE_VM isn't set, i.e. it's a fork-like clone with a new
+-	   address space.  In that case we update the cached values
+-	   from the true system pid (retrieved via __NR_getpid syscall).  */
+-	moveli r0, CLONE_VM
+-	and r0, r30, r0
+-	BNEZ r0, .Lno_reset_pid   /* CLONE_VM is set */
+-	moveli TREG_SYSCALL_NR_NAME, __NR_getpid
+-	swint1
+-	ADDLI_PTR r2, tp, PID_OFFSET
+-	{
+-	 ST4 r2, r0
+-	 ADDLI_PTR r2, tp, TID_OFFSET
+-	}
+-	ST4 r2, r0
+-.Lno_reset_pid:
+ 	{
+ 	 /* Invoke user function with specified argument. */
+ 	 move r0, r31
+diff --git a/sysdeps/unix/sysv/linux/tile/vfork.S b/sysdeps/unix/sysv/linux/tile/vfork.S
+index d8c5ce3e24..2272777187 100644
+--- a/sysdeps/unix/sysv/linux/tile/vfork.S
++++ b/sysdeps/unix/sysv/linux/tile/vfork.S
+@@ -29,18 +29,6 @@
+ 
+ 	.text
+ ENTRY (__vfork)
+-	{
+-	 addli r11, tp, PID_OFFSET	/* Point at PID. */
+-	 movei r13, 1
+-	}
+-	{
+-	 LD4U r12, r11			/* Load the saved PID.  */
+-	 shli r13, r13, 31		/* Build 0x80000000. */
+-	}
+-	sub r12, zero, r12		/* Negate it.  */
+-	CMOVEQZ r12, r12, r13		/* Replace zero pids.  */
+-	ST4 r11, r12			/* Store the temporary PID.  */
+-
+ 	{
+ 	 moveli r0, CLONE_VFORK | CLONE_VM | SIGCHLD
+ 	 move r1, zero
+@@ -52,22 +40,6 @@ ENTRY (__vfork)
+ 	moveli TREG_SYSCALL_NR_NAME, __NR_clone
+ 	swint1
+ 
+-	BEQZ r0, 1f			/* If we are the parent... */
+-	{
+-	 addli r11, tp, PID_OFFSET	/* Point at PID. */
+-	 movei r13, 1
+-	}
+-	{
+-	 LD4U r12, r11			/* Load the saved PID.  */
+-	 shli r13, r13, 31		/* Build 0x80000000. */
+-	}
+-	{
+-	 CMPEQ r13, r12, r12		/* Test for that value. */
+-	 sub r12, zero, r12		/* Re-negate it.  */
+-	}
+-	CMOVNEZ r12, r13, zero		/* Replace zero pids.  */
+-	ST4 r11, r12			/* Restore the PID.  */
+-1:
+ 	BNEZ r1, 0f
+ 	jrp lr
+ PSEUDO_END (__vfork)
+diff --git a/sysdeps/unix/sysv/linux/tst-clone2.c b/sysdeps/unix/sysv/linux/tst-clone2.c
+index 68a7e6d6e2..1472311947 100644
+--- a/sysdeps/unix/sysv/linux/tst-clone2.c
++++ b/sysdeps/unix/sysv/linux/tst-clone2.c
+@@ -28,8 +28,11 @@
+ #include <stdlib.h>
+ #include <sys/types.h>
+ #include <sys/wait.h>
++#include <sys/syscall.h>
+ 
+-#include <tls.h> /* for THREAD_* macros.  */
++#include <stackinfo.h>  /* For _STACK_GROWS_{UP,DOWN}.  */
++
++#include <support/check.h>
+ 
+ static int sig;
+ static int pipefd[2];
+@@ -39,39 +42,35 @@ f (void *a)
+ {
+   close (pipefd[0]);
+ 
+-  pid_t pid = THREAD_GETMEM (THREAD_SELF, pid);
+-  pid_t tid = THREAD_GETMEM (THREAD_SELF, tid);
++  pid_t ppid = getppid ();
++  pid_t pid = getpid ();
++  pid_t tid = syscall (__NR_gettid);
+ 
+-  while (write (pipefd[1], &pid, sizeof pid) < 0)
+-    continue;
+-  while (write (pipefd[1], &tid, sizeof tid) < 0)
+-    continue;
++  if (write (pipefd[1], &ppid, sizeof ppid) != sizeof (ppid))
++    FAIL_EXIT1 ("write ppid failed\n");
++  if (write (pipefd[1], &pid, sizeof pid) != sizeof (pid))
++    FAIL_EXIT1 ("write pid failed\n");
++  if (write (pipefd[1], &tid, sizeof tid) != sizeof (tid))
++    FAIL_EXIT1 ("write tid failed\n");
+ 
+   return 0;
+ }
+ 
+ 
+ static int
+-clone_test (int clone_flags)
++do_test (void)
+ {
+   sig = SIGRTMIN;
+   sigset_t ss;
+   sigemptyset (&ss);
+   sigaddset (&ss, sig);
+   if (sigprocmask (SIG_BLOCK, &ss, NULL) != 0)
+-    {
+-      printf ("sigprocmask failed: %m\n");
+-      return 1;
+-    }
++    FAIL_EXIT1 ("sigprocmask failed: %m");
+ 
+   if (pipe2 (pipefd, O_CLOEXEC))
+-    {
+-      printf ("sigprocmask failed: %m\n");
+-      return 1;
+-    }
+-
+-  pid_t ppid = getpid ();
++    FAIL_EXIT1 ("pipe failed: %m");
+ 
++  int clone_flags = 0;
+ #ifdef __ia64__
+   extern int __clone2 (int (*__fn) (void *__arg), void *__child_stack_base,
+ 		       size_t __child_stack_size, int __flags,
+@@ -88,61 +87,47 @@ clone_test (int clone_flags)
+ #error "Define either _STACK_GROWS_DOWN or _STACK_GROWS_UP"
+ #endif
+ #endif
++
+   close (pipefd[1]);
+ 
+   if (p == -1)
++    FAIL_EXIT1("clone failed: %m");
++
++  pid_t ppid, pid, tid;
++  if (read (pipefd[0], &ppid, sizeof pid) != sizeof pid)
+     {
+-      printf ("clone failed: %m\n");
+-      return 1;
++      kill (p, SIGKILL);
++      FAIL_EXIT1 ("read ppid failed: %m");
+     }
+-
+-  pid_t pid, tid;
+   if (read (pipefd[0], &pid, sizeof pid) != sizeof pid)
+     {
+-      printf ("read pid failed: %m\n");
+       kill (p, SIGKILL);
+-      return 1;
++      FAIL_EXIT1 ("read pid failed: %m");
+     }
+   if (read (pipefd[0], &tid, sizeof tid) != sizeof tid)
+     {
+-      printf ("read pid failed: %m\n");
+       kill (p, SIGKILL);
+-      return 1;
++      FAIL_EXIT1 ("read tid failed: %m");
+     }
+ 
+   close (pipefd[0]);
+ 
+   int ret = 0;
+ 
+-  /* For CLONE_VM glibc clone implementation does not change the pthread
+-     pid/tid field.  */
+-  if ((clone_flags & CLONE_VM) == CLONE_VM)
+-    {
+-      if ((ppid != pid) || (ppid != tid))
+-	{
+-	  printf ("parent pid (%i) != received pid/tid (%i/%i)\n",
+-		  (int)ppid, (int)pid, (int)tid);
+-	  ret = 1;
+-	}
+-    }
+-  /* For any other flag clone updates the new pthread pid and tid with
+-     the clone return value.  */
+-  else
+-    {
+-      if ((p != pid) || (p != tid))
+-	{
+-	  printf ("child pid (%i) != received pid/tid (%i/%i)\n",
+-		  (int)p, (int)pid, (int)tid);
+-	  ret = 1;
+-	}
+-    }
++  pid_t own_pid = getpid ();
++  pid_t own_tid = syscall (__NR_gettid);
++
++  /* Some sanity checks for clone syscall: returned ppid should be current
++     pid and both returned tid/pid should be different from current one.  */
++  if ((ppid != own_pid) || (pid == own_pid) || (tid == own_tid))
++    FAIL_RET ("ppid=%i pid=%i tid=%i | own_pid=%i own_tid=%i",
++	      (int)ppid, (int)pid, (int)tid, (int)own_pid, (int)own_tid);
+ 
+   int e;
+   if (waitpid (p, &e, __WCLONE) != p)
+     {
+-      puts ("waitpid failed");
+       kill (p, SIGKILL);
+-      return 1;
++      FAIL_EXIT1 ("waitpid failed");
+     }
+   if (!WIFEXITED (e))
+     {
+@@ -150,29 +135,12 @@ clone_test (int clone_flags)
+ 	printf ("died from signal %s\n", strsignal (WTERMSIG (e)));
+       else
+ 	puts ("did not terminate correctly");
+-      return 1;
++      exit (EXIT_FAILURE);
+     }
+   if (WEXITSTATUS (e) != 0)
+-    {
+-      printf ("exit code %d\n", WEXITSTATUS (e));
+-      return 1;
+-    }
++    FAIL_EXIT1 ("exit code %d", WEXITSTATUS (e));
+ 
+   return ret;
+ }
+ 
+-int
+-do_test (void)
+-{
+-  /* First, check that the clone implementation, without any flag, updates
+-     the struct pthread to contain the new PID and TID.  */
+-  int ret = clone_test (0);
+-  /* Second, check that with CLONE_VM the struct pthread PID and TID fields
+-     remain unmodified after the clone.  Any modifications would cause problem
+-     for the parent as described in bug 19957.  */
+-  ret += clone_test (CLONE_VM);
+-  return ret;
+-}
+-
+-#define TEST_FUNCTION do_test ()
+-#include "../test-skeleton.c"
++#include <support/test-driver.c>
+diff --git a/sysdeps/unix/sysv/linux/wordsize-64/globfree64.c b/sysdeps/unix/sysv/linux/wordsize-64/globfree64.c
+new file mode 100644
+index 0000000000..af035e1514
+--- /dev/null
++++ b/sysdeps/unix/sysv/linux/wordsize-64/globfree64.c
+@@ -0,0 +1,2 @@
++/* This file is here so sysdeps/gnu/glob64.c doesn't take precedence.  */
++#include <sysdeps/wordsize-64/globfree64.c>
+diff --git a/sysdeps/unix/sysv/linux/x86_64/clone.S b/sysdeps/unix/sysv/linux/x86_64/clone.S
+index 66f4b11490..5629aed395 100644
+--- a/sysdeps/unix/sysv/linux/x86_64/clone.S
++++ b/sysdeps/unix/sysv/linux/x86_64/clone.S
+@@ -91,14 +91,6 @@ L(thread_start):
+ 	   the outermost frame obviously.  */
+ 	xorl	%ebp, %ebp
+ 
+-	andq	$CLONE_VM, %rdi
+-	jne	1f
+-	movl	$SYS_ify(getpid), %eax
+-	syscall
+-	movl	%eax, %fs:PID
+-	movl	%eax, %fs:TID
+-1:
+-
+ 	/* Set up arguments for the function call.  */
+ 	popq	%rax		/* Function to call.  */
+ 	popq	%rdi		/* Argument.  */
+diff --git a/sysdeps/unix/sysv/linux/x86_64/vfork.S b/sysdeps/unix/sysv/linux/x86_64/vfork.S
+index 8332ade9fb..cdd2dea32a 100644
+--- a/sysdeps/unix/sysv/linux/x86_64/vfork.S
++++ b/sysdeps/unix/sysv/linux/x86_64/vfork.S
+@@ -34,16 +34,6 @@ ENTRY (__vfork)
+ 	cfi_adjust_cfa_offset(-8)
+ 	cfi_register(%rip, %rdi)
+ 
+-	/* Save the TCB-cached PID away in %esi, and then negate the TCB
+-           field.  But if it's zero, set it to 0x80000000 instead.  See
+-           raise.c for the logic that relies on this value.  */
+-	movl	%fs:PID, %esi
+-	movl	$0x80000000, %ecx
+-	movl	%esi, %edx
+-	negl	%edx
+-	cmove	%ecx, %edx
+-	movl	%edx, %fs:PID
+-
+ 	/* Stuff the syscall number in RAX and enter into the kernel.  */
+ 	movl	$SYS_ify (vfork), %eax
+ 	syscall
+@@ -52,14 +42,6 @@ ENTRY (__vfork)
+ 	pushq	%rdi
+ 	cfi_adjust_cfa_offset(8)
+ 
+-	/* Restore the original value of the TCB cache of the PID, if we're
+-	   the parent.  But in the child (syscall return value equals zero),
+-	   leave things as they are.  */
+-	testq	%rax, %rax
+-	je	1f
+-	movl	%esi, %fs:PID
+-1:
+-
+ 	cmpl	$-4095, %eax
+ 	jae SYSCALL_ERROR_LABEL		/* Branch forward if it failed.  */
+ 
+diff --git a/sysdeps/unix/sysv/linux/x86_64/x32/globfree.c b/sysdeps/unix/sysv/linux/x86_64/x32/globfree.c
+new file mode 100644
+index 0000000000..b76a761c17
+--- /dev/null
++++ b/sysdeps/unix/sysv/linux/x86_64/x32/globfree.c
+@@ -0,0 +1 @@
++#include <sysdeps/wordsize-64/globfree.c>
+diff --git a/sysdeps/wordsize-64/glob.c b/sysdeps/wordsize-64/glob.c
+index 082faf1c70..954e8d37e2 100644
+--- a/sysdeps/wordsize-64/glob.c
++++ b/sysdeps/wordsize-64/glob.c
+@@ -4,5 +4,3 @@
+ #undef glob64
+ #undef globfree64
+ weak_alias (glob, glob64)
+-weak_alias (globfree, globfree64)
+-libc_hidden_ver (globfree, globfree64)
+diff --git a/sysdeps/wordsize-64/globfree.c b/sysdeps/wordsize-64/globfree.c
+new file mode 100644
+index 0000000000..ec8c35b489
+--- /dev/null
++++ b/sysdeps/wordsize-64/globfree.c
+@@ -0,0 +1,5 @@
++#define globfree64 __no_globfree64_decl
++#include <posix/globfree.c>
++#undef globfree64
++weak_alias (globfree, globfree64)
++libc_hidden_ver (globfree, globfree64)
+diff --git a/sysdeps/wordsize-64/globfree64.c b/sysdeps/wordsize-64/globfree64.c
+new file mode 100644
+index 0000000000..a0f57ff4b3
+--- /dev/null
++++ b/sysdeps/wordsize-64/globfree64.c
+@@ -0,0 +1 @@
++/* globfree64 is in globfree.c */
+diff --git a/sysdeps/x86/cpu-features-offsets.sym b/sysdeps/x86/cpu-features-offsets.sym
+index f6739fae81..33dd094e37 100644
+--- a/sysdeps/x86/cpu-features-offsets.sym
++++ b/sysdeps/x86/cpu-features-offsets.sym
+@@ -15,6 +15,7 @@ CPUID_ECX_OFFSET	offsetof (struct cpuid_registers, ecx)
+ CPUID_EDX_OFFSET	offsetof (struct cpuid_registers, edx)
+ FAMILY_OFFSET		offsetof (struct cpu_features, family)
+ MODEL_OFFSET		offsetof (struct cpu_features, model)
++XSAVE_STATE_SIZE_OFFSET	offsetof (struct cpu_features, xsave_state_size)
+ FEATURE_OFFSET		offsetof (struct cpu_features, feature)
+ FEATURE_SIZE		sizeof (unsigned int)
+ 
+diff --git a/sysdeps/x86/cpu-features.c b/sysdeps/x86/cpu-features.c
+index 9ce4b495a5..9eca98817d 100644
+--- a/sysdeps/x86/cpu-features.c
++++ b/sysdeps/x86/cpu-features.c
+@@ -18,6 +18,7 @@
+ 
+ #include <cpuid.h>
+ #include <cpu-features.h>
++#include <libc-internal.h>
+ 
+ static void
+ get_common_indeces (struct cpu_features *cpu_features,
+@@ -88,6 +89,71 @@ get_common_indeces (struct cpu_features *cpu_features,
+ 	    cpu_features->feature[index_arch_FMA_Usable]
+ 	      |= bit_arch_FMA_Usable;
+ 	}
++
++      /* For _dl_runtime_resolve, set xsave_state_size to xsave area
++	 size + integer register save size and align it to 64 bytes.  */
++      if (cpu_features->max_cpuid >= 0xd)
++	{
++	  unsigned int eax, ebx, ecx, edx;
++
++	  __cpuid_count (0xd, 0, eax, ebx, ecx, edx);
++	  if (ebx != 0)
++	    {
++	      cpu_features->xsave_state_size
++		= ALIGN_UP (ebx + STATE_SAVE_OFFSET, 64);
++
++	      __cpuid_count (0xd, 1, eax, ebx, ecx, edx);
++
++	      /* Check if XSAVEC is available.  */
++	      if ((eax & (1 << 1)) != 0)
++		{
++		  unsigned int xstate_comp_offsets[32];
++		  unsigned int xstate_comp_sizes[32];
++		  unsigned int i;
++
++		  xstate_comp_offsets[0] = 0;
++		  xstate_comp_offsets[1] = 160;
++		  xstate_comp_offsets[2] = 576;
++		  xstate_comp_sizes[0] = 160;
++		  xstate_comp_sizes[1] = 256;
++
++		  for (i = 2; i < 32; i++)
++		    {
++		      if ((STATE_SAVE_MASK & (1 << i)) != 0)
++			{
++			  __cpuid_count (0xd, i, eax, ebx, ecx, edx);
++			  xstate_comp_sizes[i] = eax;
++			}
++		      else
++			{
++			  ecx = 0;
++			  xstate_comp_sizes[i] = 0;
++			}
++
++		      if (i > 2)
++			{
++			  xstate_comp_offsets[i]
++			    = (xstate_comp_offsets[i - 1]
++			       + xstate_comp_sizes[i -1]);
++			  if ((ecx & (1 << 1)) != 0)
++			    xstate_comp_offsets[i]
++			      = ALIGN_UP (xstate_comp_offsets[i], 64);
++			}
++		    }
++
++		  /* Use XSAVEC.  */
++		  unsigned int size
++		    = xstate_comp_offsets[31] + xstate_comp_sizes[31];
++		  if (size)
++		    {
++		      cpu_features->xsave_state_size
++			= ALIGN_UP (size + STATE_SAVE_OFFSET, 64);
++		      cpu_features->feature[index_arch_XSAVEC_Usable]
++			|= bit_arch_XSAVEC_Usable;
++		    }
++		}
++	    }
++	}
+     }
+ }
+ 
+@@ -133,8 +199,6 @@ init_cpu_features (struct cpu_features *cpu_features)
+ 
+ 	    case 0x57:
+ 	      /* Knights Landing.  Enable Silvermont optimizations.  */
+-	      cpu_features->feature[index_arch_Prefer_No_VZEROUPPER]
+-		|= bit_arch_Prefer_No_VZEROUPPER;
+ 
+ 	    case 0x5c:
+ 	    case 0x5f:
+@@ -205,6 +269,16 @@ init_cpu_features (struct cpu_features *cpu_features)
+       if (CPU_FEATURES_ARCH_P (cpu_features, AVX2_Usable))
+ 	cpu_features->feature[index_arch_AVX_Fast_Unaligned_Load]
+ 	  |= bit_arch_AVX_Fast_Unaligned_Load;
++
++      /* Since AVX512ER is unique to Xeon Phi, set Prefer_No_VZEROUPPER
++         if AVX512ER is available.  Don't use AVX512 to avoid lower CPU
++	 frequency if AVX512ER isn't available.  */
++      if (CPU_FEATURES_CPU_P (cpu_features, AVX512ER))
++	cpu_features->feature[index_arch_Prefer_No_VZEROUPPER]
++	  |= bit_arch_Prefer_No_VZEROUPPER;
++      else
++	cpu_features->feature[index_arch_Prefer_No_AVX512]
++	  |= bit_arch_Prefer_No_AVX512;
+     }
+   /* This spells out "AuthenticAMD".  */
+   else if (ebx == 0x68747541 && ecx == 0x444d4163 && edx == 0x69746e65)
+diff --git a/sysdeps/x86/cpu-features.h b/sysdeps/x86/cpu-features.h
+index 97ffe765f4..507a141414 100644
+--- a/sysdeps/x86/cpu-features.h
++++ b/sysdeps/x86/cpu-features.h
+@@ -37,6 +37,8 @@
+ #define bit_arch_Prefer_No_VZEROUPPER		(1 << 17)
+ #define bit_arch_Fast_Unaligned_Copy		(1 << 18)
+ #define bit_arch_Prefer_ERMS			(1 << 19)
++#define bit_arch_Prefer_No_AVX512		(1 << 20)
++#define bit_arch_XSAVEC_Usable			(1 << 21)
+ 
+ /* CPUID Feature flags.  */
+ 
+@@ -60,6 +62,11 @@
+ #define bit_cpu_AVX2		(1 << 5)
+ #define bit_cpu_AVX512F		(1 << 16)
+ #define bit_cpu_AVX512DQ	(1 << 17)
++#define bit_cpu_AVX512PF	(1 << 26)
++#define bit_cpu_AVX512ER	(1 << 27)
++#define bit_cpu_AVX512CD	(1 << 28)
++#define bit_cpu_AVX512BW	(1 << 30)
++#define bit_cpu_AVX512VL	(1u << 31)
+ 
+ /* XCR0 Feature flags.  */
+ #define bit_XMM_state		(1 << 1)
+@@ -74,6 +81,15 @@
+ /* The current maximum size of the feature integer bit array.  */
+ #define FEATURE_INDEX_MAX 1
+ 
++/* Offset for fxsave/xsave area used by _dl_runtime_resolve.  Also need
++   space to preserve RCX, RDX, RSI, RDI, R8, R9 and RAX.  It must be
++   aligned to 16 bytes for fxsave and 64 bytes for xsave.  */
++#define STATE_SAVE_OFFSET (8 * 7 + 8)
++
++/* Save SSE, AVX, AVX512, mask and bound registers.  */
++#define STATE_SAVE_MASK \
++  ((1 << 1) | (1 << 2) | (1 << 3) | (1 << 5) | (1 << 6) | (1 << 7))
++
+ #ifdef	__ASSEMBLER__
+ 
+ # include <cpu-features-offsets.h>
+@@ -107,6 +123,9 @@
+ # define index_arch_Prefer_No_VZEROUPPER FEATURE_INDEX_1*FEATURE_SIZE
+ # define index_arch_Fast_Unaligned_Copy	FEATURE_INDEX_1*FEATURE_SIZE
+ # define index_arch_Prefer_ERMS		FEATURE_INDEX_1*FEATURE_SIZE
++# define index_arch_Use_dl_runtime_resolve_opt FEATURE_INDEX_1*FEATURE_SIZE
++# define index_arch_Use_dl_runtime_resolve_slow FEATURE_INDEX_1*FEATURE_SIZE
++# define index_arch_Prefer_No_AVX512	FEATURE_INDEX_1*FEATURE_SIZE
+ 
+ 
+ # if defined (_LIBC) && !IS_IN (nonlib)
+@@ -195,6 +214,12 @@ struct cpu_features
+   } cpuid[COMMON_CPUID_INDEX_MAX];
+   unsigned int family;
+   unsigned int model;
++  /* The type must be unsigned long int so that we use
++
++	sub xsave_state_size_offset(%rip) %RSP_LP
++
++     in _dl_runtime_resolve.  */
++  unsigned long int xsave_state_size;
+   unsigned int feature[FEATURE_INDEX_MAX];
+ };
+ 
+@@ -232,6 +257,11 @@ extern const struct cpu_features *__get_cpu_features (void)
+ # define index_cpu_AVX2		COMMON_CPUID_INDEX_7
+ # define index_cpu_AVX512F	COMMON_CPUID_INDEX_7
+ # define index_cpu_AVX512DQ	COMMON_CPUID_INDEX_7
++# define index_cpu_AVX512PF	COMMON_CPUID_INDEX_7
++# define index_cpu_AVX512ER	COMMON_CPUID_INDEX_7
++# define index_cpu_AVX512CD	COMMON_CPUID_INDEX_7
++# define index_cpu_AVX512BW	COMMON_CPUID_INDEX_7
++# define index_cpu_AVX512VL	COMMON_CPUID_INDEX_7
+ # define index_cpu_ERMS		COMMON_CPUID_INDEX_7
+ # define index_cpu_RTM		COMMON_CPUID_INDEX_7
+ # define index_cpu_FMA		COMMON_CPUID_INDEX_1
+@@ -250,6 +280,11 @@ extern const struct cpu_features *__get_cpu_features (void)
+ # define reg_AVX2		ebx
+ # define reg_AVX512F		ebx
+ # define reg_AVX512DQ		ebx
++# define reg_AVX512PF		ebx
++# define reg_AVX512ER		ebx
++# define reg_AVX512CD		ebx
++# define reg_AVX512BW		ebx
++# define reg_AVX512VL		ebx
+ # define reg_ERMS		ebx
+ # define reg_RTM		ebx
+ # define reg_FMA		ecx
+@@ -277,6 +312,8 @@ extern const struct cpu_features *__get_cpu_features (void)
+ # define index_arch_Prefer_No_VZEROUPPER FEATURE_INDEX_1
+ # define index_arch_Fast_Unaligned_Copy	FEATURE_INDEX_1
+ # define index_arch_Prefer_ERMS		FEATURE_INDEX_1
++# define index_arch_Prefer_No_AVX512	FEATURE_INDEX_1
++# define index_arch_XSAVEC_Usable	FEATURE_INDEX_1
+ 
+ #endif	/* !__ASSEMBLER__ */
+ 
+diff --git a/sysdeps/x86_64/Makefile b/sysdeps/x86_64/Makefile
+index 6d99284cd0..cc990a9685 100644
+--- a/sysdeps/x86_64/Makefile
++++ b/sysdeps/x86_64/Makefile
+@@ -27,7 +27,7 @@ ifeq ($(subdir),elf)
+ CFLAGS-.os += $(if $(filter $(@F),$(patsubst %,%.os,$(all-rtld-routines))),\
+ 		   -mno-mmx)
+ 
+-sysdep-dl-routines += tlsdesc dl-tlsdesc
++sysdep-dl-routines += tlsdesc dl-tlsdesc tls_get_addr
+ 
+ tests += ifuncmain8
+ modules-names += ifuncmod8
+@@ -49,9 +49,12 @@ extra-test-objs += tst-quadmod1pie.o tst-quadmod2pie.o
+ $(objpfx)tst-quad1pie: $(objpfx)tst-quadmod1pie.o
+ $(objpfx)tst-quad2pie: $(objpfx)tst-quadmod2pie.o
+ 
+-tests += tst-audit3 tst-audit4 tst-audit5 tst-audit6 tst-audit7 tst-audit10
+-test-extras += tst-audit4-aux tst-audit10-aux
+-extra-test-objs += tst-audit4-aux.o tst-audit10-aux.o
++tests += tst-audit3 tst-audit4 tst-audit5 tst-audit6 tst-audit7 \
++	 tst-audit10 tst-sse tst-avx tst-avx512
++test-extras += tst-audit4-aux tst-audit10-aux \
++	       tst-avx-aux tst-avx512-aux
++extra-test-objs += tst-audit4-aux.o tst-audit10-aux.o \
++		   tst-avx-aux.o tst-avx512-aux.o
+ 
+ tests += tst-split-dynreloc
+ LDFLAGS-tst-split-dynreloc = -Wl,-T,$(..)sysdeps/x86_64/tst-split-dynreloc.lds
+@@ -62,7 +65,8 @@ modules-names += tst-auditmod3a tst-auditmod3b \
+ 		tst-auditmod5a tst-auditmod5b \
+ 		tst-auditmod6a tst-auditmod6b tst-auditmod6c \
+ 		tst-auditmod7a tst-auditmod7b \
+-		tst-auditmod10a tst-auditmod10b
++		tst-auditmod10a tst-auditmod10b \
++		tst-ssemod tst-avxmod tst-avx512mod
+ 
+ $(objpfx)tst-audit3: $(objpfx)tst-auditmod3a.so
+ $(objpfx)tst-audit3.out: $(objpfx)tst-auditmod3b.so
+@@ -89,6 +93,10 @@ $(objpfx)tst-audit10: $(objpfx)tst-audit10-aux.o $(objpfx)tst-auditmod10a.so
+ $(objpfx)tst-audit10.out: $(objpfx)tst-auditmod10b.so
+ tst-audit10-ENV = LD_AUDIT=$(objpfx)tst-auditmod10b.so
+ 
++$(objpfx)tst-sse: $(objpfx)tst-ssemod.so
++$(objpfx)tst-avx: $(objpfx)tst-avx-aux.o $(objpfx)tst-avxmod.so
++$(objpfx)tst-avx512: $(objpfx)tst-avx512-aux.o $(objpfx)tst-avx512mod.so
++
+ AVX-CFLAGS=-mavx -mno-vzeroupper
+ CFLAGS-tst-audit4-aux.c += $(AVX-CFLAGS)
+ CFLAGS-tst-auditmod4a.c += $(AVX-CFLAGS)
+@@ -96,14 +104,18 @@ CFLAGS-tst-auditmod4b.c += $(AVX-CFLAGS)
+ CFLAGS-tst-auditmod6b.c += $(AVX-CFLAGS)
+ CFLAGS-tst-auditmod6c.c += $(AVX-CFLAGS)
+ CFLAGS-tst-auditmod7b.c += $(AVX-CFLAGS)
++CFLAGS-tst-avx-aux.c += $(AVX-CFLAGS)
++CFLAGS-tst-avxmod.c += $(AVX-CFLAGS)
+ ifeq (yes,$(config-cflags-avx512))
+ AVX512-CFLAGS = -mavx512f
+ CFLAGS-tst-audit10-aux.c += $(AVX512-CFLAGS)
+ CFLAGS-tst-auditmod10a.c += $(AVX512-CFLAGS)
+ CFLAGS-tst-auditmod10b.c += $(AVX512-CFLAGS)
++CFLAGS-tst-avx512-aux.c += $(AVX512-CFLAGS)
++CFLAGS-tst-avx512mod.c += $(AVX512-CFLAGS)
+ endif
+ endif
+ 
+ ifeq ($(subdir),csu)
+-gen-as-const-headers += tlsdesc.sym
++gen-as-const-headers += tlsdesc.sym rtld-offsets.sym
+ endif
+diff --git a/sysdeps/x86_64/dl-machine.h b/sysdeps/x86_64/dl-machine.h
+index ed0c1a8efd..8355432dfc 100644
+--- a/sysdeps/x86_64/dl-machine.h
++++ b/sysdeps/x86_64/dl-machine.h
+@@ -66,9 +66,9 @@ static inline int __attribute__ ((unused, always_inline))
+ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+ {
+   Elf64_Addr *got;
+-  extern void _dl_runtime_resolve_sse (ElfW(Word)) attribute_hidden;
+-  extern void _dl_runtime_resolve_avx (ElfW(Word)) attribute_hidden;
+-  extern void _dl_runtime_resolve_avx512 (ElfW(Word)) attribute_hidden;
++  extern void _dl_runtime_resolve_fxsave (ElfW(Word)) attribute_hidden;
++  extern void _dl_runtime_resolve_xsave (ElfW(Word)) attribute_hidden;
++  extern void _dl_runtime_resolve_xsavec (ElfW(Word)) attribute_hidden;
+   extern void _dl_runtime_profile_sse (ElfW(Word)) attribute_hidden;
+   extern void _dl_runtime_profile_avx (ElfW(Word)) attribute_hidden;
+   extern void _dl_runtime_profile_avx512 (ElfW(Word)) attribute_hidden;
+@@ -117,12 +117,14 @@ elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
+ 	  /* This function will get called to fix up the GOT entry
+ 	     indicated by the offset on the stack, and then jump to
+ 	     the resolved address.  */
+-	  if (HAS_ARCH_FEATURE (AVX512F_Usable))
+-	    *(ElfW(Addr) *) (got + 2) = (ElfW(Addr)) &_dl_runtime_resolve_avx512;
+-	  else if (HAS_ARCH_FEATURE (AVX_Usable))
+-	    *(ElfW(Addr) *) (got + 2) = (ElfW(Addr)) &_dl_runtime_resolve_avx;
++	  if (GLRO(dl_x86_cpu_features).xsave_state_size != 0)
++	    *(ElfW(Addr) *) (got + 2)
++	      = (HAS_ARCH_FEATURE (XSAVEC_Usable)
++		 ? (ElfW(Addr)) &_dl_runtime_resolve_xsavec
++		 : (ElfW(Addr)) &_dl_runtime_resolve_xsave);
+ 	  else
+-	    *(ElfW(Addr) *) (got + 2) = (ElfW(Addr)) &_dl_runtime_resolve_sse;
++	    *(ElfW(Addr) *) (got + 2)
++	      = (ElfW(Addr)) &_dl_runtime_resolve_fxsave;
+ 	}
+     }
+ 
+diff --git a/sysdeps/x86_64/dl-tls.c b/sysdeps/x86_64/dl-tls.c
+new file mode 100644
+index 0000000000..3584805c8e
+--- /dev/null
++++ b/sysdeps/x86_64/dl-tls.c
+@@ -0,0 +1,53 @@
++/* Thread-local storage handling in the ELF dynamic linker.  x86-64 version.
++   Copyright (C) 2017 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/>.  */
++
++#ifdef SHARED
++/* Work around GCC PR58066, due to which __tls_get_addr may be called
++   with an unaligned stack.  The compat implementation is in
++   tls_get_addr-compat.S.  */
++
++# include <dl-tls.h>
++
++/* Define __tls_get_addr within elf/dl-tls.c under a different
++   name.  */
++extern __typeof__ (__tls_get_addr) ___tls_get_addr;
++
++# define __tls_get_addr ___tls_get_addr
++# include <elf/dl-tls.c>
++# undef __tls_get_addr
++
++hidden_ver (___tls_get_addr, __tls_get_addr)
++
++/* Only handle slow paths for __tls_get_addr.  */
++attribute_hidden
++void *
++__tls_get_addr_slow (GET_ADDR_ARGS)
++{
++  dtv_t *dtv = THREAD_DTV ();
++
++  if (__glibc_unlikely (dtv[0].counter != GL(dl_tls_generation)))
++    return update_get_addr (GET_ADDR_PARAM);
++
++  return tls_get_addr_tail (GET_ADDR_PARAM, dtv, NULL);
++}
++#else
++
++/* No compatibility symbol needed.  */
++# include <elf/dl-tls.c>
++
++#endif
+diff --git a/sysdeps/x86_64/dl-tls.h b/sysdeps/x86_64/dl-tls.h
+index cf6c107f54..fa5bf6cd93 100644
+--- a/sysdeps/x86_64/dl-tls.h
++++ b/sysdeps/x86_64/dl-tls.h
+@@ -16,6 +16,9 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
++#ifndef _X86_64_DL_TLS_H
++#define _X86_64_DL_TLS_H
++
+ #include <stdint.h>
+ 
+ /* Type used for the representation of TLS information in the GOT.  */
+@@ -27,3 +30,5 @@ typedef struct dl_tls_index
+ 
+ 
+ extern void *__tls_get_addr (tls_index *ti);
++
++#endif /* _X86_64_DL_TLS_H */
+diff --git a/sysdeps/x86_64/dl-trampoline.S b/sysdeps/x86_64/dl-trampoline.S
+index 12f1a5cf84..b4cda0f535 100644
+--- a/sysdeps/x86_64/dl-trampoline.S
++++ b/sysdeps/x86_64/dl-trampoline.S
+@@ -18,6 +18,7 @@
+ 
+ #include <config.h>
+ #include <sysdep.h>
++#include <cpu-features.h>
+ #include <link-defines.h>
+ 
+ #ifndef DL_STACK_ALIGNMENT
+@@ -33,41 +34,24 @@
+ # define DL_STACK_ALIGNMENT 8
+ #endif
+ 
+-#ifndef DL_RUNTIME_UNALIGNED_VEC_SIZE
+-/* The maximum size in bytes of unaligned vector load and store in the
+-   dynamic linker.  Since SSE optimized memory/string functions with
+-   aligned SSE register load and store are used in the dynamic linker,
+-   we must set this to 8 so that _dl_runtime_resolve_sse will align the
+-   stack before calling _dl_fixup.  */
+-# define DL_RUNTIME_UNALIGNED_VEC_SIZE 8
+-#endif
+-
+-/* True if _dl_runtime_resolve should align stack to VEC_SIZE bytes.  */
++/* True if _dl_runtime_resolve should align stack for STATE_SAVE or align
++   stack to 16 bytes before calling _dl_fixup.  */
+ #define DL_RUNTIME_RESOLVE_REALIGN_STACK \
+-  (VEC_SIZE > DL_STACK_ALIGNMENT \
+-   && VEC_SIZE > DL_RUNTIME_UNALIGNED_VEC_SIZE)
+-
+-/* Align vector register save area to 16 bytes.  */
+-#define REGISTER_SAVE_VEC_OFF	0
++  (STATE_SAVE_ALIGNMENT > DL_STACK_ALIGNMENT \
++   || 16 > DL_STACK_ALIGNMENT)
+ 
+ /* Area on stack to save and restore registers used for parameter
+    passing when calling _dl_fixup.  */
+ #ifdef __ILP32__
+-# define REGISTER_SAVE_RAX	(REGISTER_SAVE_VEC_OFF + VEC_SIZE * 8)
+ # define PRESERVE_BND_REGS_PREFIX
+ #else
+-/* Align bound register save area to 16 bytes.  */
+-# define REGISTER_SAVE_BND0	(REGISTER_SAVE_VEC_OFF + VEC_SIZE * 8)
+-# define REGISTER_SAVE_BND1	(REGISTER_SAVE_BND0 + 16)
+-# define REGISTER_SAVE_BND2	(REGISTER_SAVE_BND1 + 16)
+-# define REGISTER_SAVE_BND3	(REGISTER_SAVE_BND2 + 16)
+-# define REGISTER_SAVE_RAX	(REGISTER_SAVE_BND3 + 16)
+ # ifdef HAVE_MPX_SUPPORT
+ #  define PRESERVE_BND_REGS_PREFIX bnd
+ # else
+ #  define PRESERVE_BND_REGS_PREFIX .byte 0xf2
+ # endif
+ #endif
++#define REGISTER_SAVE_RAX	0
+ #define REGISTER_SAVE_RCX	(REGISTER_SAVE_RAX + 8)
+ #define REGISTER_SAVE_RDX	(REGISTER_SAVE_RCX + 8)
+ #define REGISTER_SAVE_RSI	(REGISTER_SAVE_RDX + 8)
+@@ -79,50 +63,56 @@
+ 
+ #define VEC_SIZE		64
+ #define VMOVA			vmovdqa64
+-#if DL_RUNTIME_RESOLVE_REALIGN_STACK || VEC_SIZE <= DL_STACK_ALIGNMENT
+-# define VMOV			vmovdqa64
+-#else
+-# define VMOV			vmovdqu64
+-#endif
+ #define VEC(i)			zmm##i
+-#define _dl_runtime_resolve	_dl_runtime_resolve_avx512
+ #define _dl_runtime_profile	_dl_runtime_profile_avx512
+ #include "dl-trampoline.h"
+-#undef _dl_runtime_resolve
+ #undef _dl_runtime_profile
+ #undef VEC
+-#undef VMOV
+ #undef VMOVA
+ #undef VEC_SIZE
+ 
+ #define VEC_SIZE		32
+ #define VMOVA			vmovdqa
+-#if DL_RUNTIME_RESOLVE_REALIGN_STACK || VEC_SIZE <= DL_STACK_ALIGNMENT
+-# define VMOV			vmovdqa
+-#else
+-# define VMOV			vmovdqu
+-#endif
+ #define VEC(i)			ymm##i
+-#define _dl_runtime_resolve	_dl_runtime_resolve_avx
+ #define _dl_runtime_profile	_dl_runtime_profile_avx
+ #include "dl-trampoline.h"
+-#undef _dl_runtime_resolve
+ #undef _dl_runtime_profile
+ #undef VEC
+-#undef VMOV
+ #undef VMOVA
+ #undef VEC_SIZE
+ 
+ /* movaps/movups is 1-byte shorter.  */
+ #define VEC_SIZE		16
+ #define VMOVA			movaps
+-#if DL_RUNTIME_RESOLVE_REALIGN_STACK || VEC_SIZE <= DL_STACK_ALIGNMENT
+-# define VMOV			movaps
+-#else
+-# define VMOV			movups
+-#endif
+ #define VEC(i)			xmm##i
+-#define _dl_runtime_resolve	_dl_runtime_resolve_sse
+ #define _dl_runtime_profile	_dl_runtime_profile_sse
+ #undef RESTORE_AVX
+ #include "dl-trampoline.h"
++#undef _dl_runtime_profile
++#undef VEC
++#undef VMOVA
++#undef VEC_SIZE
++
++#define USE_FXSAVE
++#define STATE_SAVE_ALIGNMENT	16
++#define _dl_runtime_resolve	_dl_runtime_resolve_fxsave
++#include "dl-trampoline.h"
++#undef _dl_runtime_resolve
++#undef USE_FXSAVE
++#undef STATE_SAVE_ALIGNMENT
++
++#define USE_XSAVE
++#define STATE_SAVE_ALIGNMENT	64
++#define _dl_runtime_resolve	_dl_runtime_resolve_xsave
++#include "dl-trampoline.h"
++#undef _dl_runtime_resolve
++#undef USE_XSAVE
++#undef STATE_SAVE_ALIGNMENT
++
++#define USE_XSAVEC
++#define STATE_SAVE_ALIGNMENT	64
++#define _dl_runtime_resolve	_dl_runtime_resolve_xsavec
++#include "dl-trampoline.h"
++#undef _dl_runtime_resolve
++#undef USE_XSAVEC
++#undef STATE_SAVE_ALIGNMENT
+diff --git a/sysdeps/x86_64/dl-trampoline.h b/sysdeps/x86_64/dl-trampoline.h
+index b90836ab13..b9c2f1796f 100644
+--- a/sysdeps/x86_64/dl-trampoline.h
++++ b/sysdeps/x86_64/dl-trampoline.h
+@@ -16,40 +16,47 @@
+    License along with the GNU C Library; if not, see
+    <http://www.gnu.org/licenses/>.  */
+ 
+-#undef REGISTER_SAVE_AREA_RAW
+-#ifdef __ILP32__
+-/* X32 saves RCX, RDX, RSI, RDI, R8 and R9 plus RAX as well as VEC0 to
+-   VEC7.  */
+-# define REGISTER_SAVE_AREA_RAW	(8 * 7 + VEC_SIZE * 8)
+-#else
+-/* X86-64 saves RCX, RDX, RSI, RDI, R8 and R9 plus RAX as well as
+-   BND0, BND1, BND2, BND3 and VEC0 to VEC7. */
+-# define REGISTER_SAVE_AREA_RAW	(8 * 7 + 16 * 4 + VEC_SIZE * 8)
+-#endif
++	.text
++#ifdef _dl_runtime_resolve
+ 
+-#undef REGISTER_SAVE_AREA
+-#undef LOCAL_STORAGE_AREA
+-#undef BASE
+-#if DL_RUNTIME_RESOLVE_REALIGN_STACK
+-# define REGISTER_SAVE_AREA	(REGISTER_SAVE_AREA_RAW + 8)
+-/* Local stack area before jumping to function address: RBX.  */
+-# define LOCAL_STORAGE_AREA	8
+-# define BASE			rbx
+-# if (REGISTER_SAVE_AREA % VEC_SIZE) != 0
+-#  error REGISTER_SAVE_AREA must be multples of VEC_SIZE
++# undef REGISTER_SAVE_AREA
++# undef LOCAL_STORAGE_AREA
++# undef BASE
++
++# if (STATE_SAVE_ALIGNMENT % 16) != 0
++#  error STATE_SAVE_ALIGNMENT must be multples of 16
+ # endif
+-#else
+-# define REGISTER_SAVE_AREA	REGISTER_SAVE_AREA_RAW
++
++# if (STATE_SAVE_OFFSET % STATE_SAVE_ALIGNMENT) != 0
++#  error STATE_SAVE_OFFSET must be multples of STATE_SAVE_ALIGNMENT
++# endif
++
++# if DL_RUNTIME_RESOLVE_REALIGN_STACK
++/* Local stack area before jumping to function address: RBX.  */
++#  define LOCAL_STORAGE_AREA	8
++#  define BASE			rbx
++#  ifdef USE_FXSAVE
++/* Use fxsave to save XMM registers.  */
++#   define REGISTER_SAVE_AREA	(512 + STATE_SAVE_OFFSET)
++#   if (REGISTER_SAVE_AREA % 16) != 0
++#    error REGISTER_SAVE_AREA must be multples of 16
++#   endif
++#  endif
++# else
++#  ifndef USE_FXSAVE
++#   error USE_FXSAVE must be defined
++#  endif
++/* Use fxsave to save XMM registers.  */
++#  define REGISTER_SAVE_AREA	(512 + STATE_SAVE_OFFSET + 8)
+ /* Local stack area before jumping to function address:  All saved
+    registers.  */
+-# define LOCAL_STORAGE_AREA	REGISTER_SAVE_AREA
+-# define BASE			rsp
+-# if (REGISTER_SAVE_AREA % 16) != 8
+-#  error REGISTER_SAVE_AREA must be odd multples of 8
++#  define LOCAL_STORAGE_AREA	REGISTER_SAVE_AREA
++#  define BASE			rsp
++#  if (REGISTER_SAVE_AREA % 16) != 8
++#   error REGISTER_SAVE_AREA must be odd multples of 8
++#  endif
+ # endif
+-#endif
+ 
+-	.text
+ 	.globl _dl_runtime_resolve
+ 	.hidden _dl_runtime_resolve
+ 	.type _dl_runtime_resolve, @function
+@@ -57,19 +64,30 @@
+ 	cfi_startproc
+ _dl_runtime_resolve:
+ 	cfi_adjust_cfa_offset(16) # Incorporate PLT
+-#if DL_RUNTIME_RESOLVE_REALIGN_STACK
+-# if LOCAL_STORAGE_AREA != 8
+-#  error LOCAL_STORAGE_AREA must be 8
+-# endif
++# if DL_RUNTIME_RESOLVE_REALIGN_STACK
++#  if LOCAL_STORAGE_AREA != 8
++#   error LOCAL_STORAGE_AREA must be 8
++#  endif
+ 	pushq %rbx			# push subtracts stack by 8.
+ 	cfi_adjust_cfa_offset(8)
+ 	cfi_rel_offset(%rbx, 0)
+ 	mov %RSP_LP, %RBX_LP
+ 	cfi_def_cfa_register(%rbx)
+-	and $-VEC_SIZE, %RSP_LP
+-#endif
++	and $-STATE_SAVE_ALIGNMENT, %RSP_LP
++# endif
++# ifdef REGISTER_SAVE_AREA
+ 	sub $REGISTER_SAVE_AREA, %RSP_LP
++#  if !DL_RUNTIME_RESOLVE_REALIGN_STACK
+ 	cfi_adjust_cfa_offset(REGISTER_SAVE_AREA)
++#  endif
++# else
++	# Allocate stack space of the required size to save the state.
++#  if IS_IN (rtld)
++	sub _rtld_local_ro+RTLD_GLOBAL_RO_DL_X86_CPU_FEATURES_OFFSET+XSAVE_STATE_SIZE_OFFSET(%rip), %RSP_LP
++#  else
++	sub _dl_x86_cpu_features+XSAVE_STATE_SIZE_OFFSET(%rip), %RSP_LP
++#  endif
++# endif
+ 	# Preserve registers otherwise clobbered.
+ 	movq %rax, REGISTER_SAVE_RAX(%rsp)
+ 	movq %rcx, REGISTER_SAVE_RCX(%rsp)
+@@ -78,59 +96,42 @@ _dl_runtime_resolve:
+ 	movq %rdi, REGISTER_SAVE_RDI(%rsp)
+ 	movq %r8, REGISTER_SAVE_R8(%rsp)
+ 	movq %r9, REGISTER_SAVE_R9(%rsp)
+-	VMOV %VEC(0), (REGISTER_SAVE_VEC_OFF)(%rsp)
+-	VMOV %VEC(1), (REGISTER_SAVE_VEC_OFF + VEC_SIZE)(%rsp)
+-	VMOV %VEC(2), (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 2)(%rsp)
+-	VMOV %VEC(3), (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 3)(%rsp)
+-	VMOV %VEC(4), (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 4)(%rsp)
+-	VMOV %VEC(5), (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 5)(%rsp)
+-	VMOV %VEC(6), (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 6)(%rsp)
+-	VMOV %VEC(7), (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 7)(%rsp)
+-#ifndef __ILP32__
+-	# We also have to preserve bound registers.  These are nops if
+-	# Intel MPX isn't available or disabled.
+-# ifdef HAVE_MPX_SUPPORT
+-	bndmov %bnd0, REGISTER_SAVE_BND0(%rsp)
+-	bndmov %bnd1, REGISTER_SAVE_BND1(%rsp)
+-	bndmov %bnd2, REGISTER_SAVE_BND2(%rsp)
+-	bndmov %bnd3, REGISTER_SAVE_BND3(%rsp)
++# ifdef USE_FXSAVE
++	fxsave STATE_SAVE_OFFSET(%rsp)
+ # else
+-#  if REGISTER_SAVE_BND0 == 0
+-	.byte 0x66,0x0f,0x1b,0x04,0x24
++	movl $STATE_SAVE_MASK, %eax
++	xorl %edx, %edx
++	# Clear the XSAVE Header.
++#  ifdef USE_XSAVE
++	movq %rdx, (STATE_SAVE_OFFSET + 512)(%rsp)
++	movq %rdx, (STATE_SAVE_OFFSET + 512 + 8)(%rsp)
++#  endif
++	movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 2)(%rsp)
++	movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 3)(%rsp)
++	movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 4)(%rsp)
++	movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 5)(%rsp)
++	movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 6)(%rsp)
++	movq %rdx, (STATE_SAVE_OFFSET + 512 + 8 * 7)(%rsp)
++#  ifdef USE_XSAVE
++	xsave STATE_SAVE_OFFSET(%rsp)
+ #  else
+-	.byte 0x66,0x0f,0x1b,0x44,0x24,REGISTER_SAVE_BND0
++	xsavec STATE_SAVE_OFFSET(%rsp)
+ #  endif
+-	.byte 0x66,0x0f,0x1b,0x4c,0x24,REGISTER_SAVE_BND1
+-	.byte 0x66,0x0f,0x1b,0x54,0x24,REGISTER_SAVE_BND2
+-	.byte 0x66,0x0f,0x1b,0x5c,0x24,REGISTER_SAVE_BND3
+ # endif
+-#endif
+ 	# Copy args pushed by PLT in register.
+ 	# %rdi: link_map, %rsi: reloc_index
+ 	mov (LOCAL_STORAGE_AREA + 8)(%BASE), %RSI_LP
+ 	mov LOCAL_STORAGE_AREA(%BASE), %RDI_LP
+ 	call _dl_fixup		# Call resolver.
+ 	mov %RAX_LP, %R11_LP	# Save return value
+-#ifndef __ILP32__
+-	# Restore bound registers.  These are nops if Intel MPX isn't
+-	# avaiable or disabled.
+-# ifdef HAVE_MPX_SUPPORT
+-	bndmov REGISTER_SAVE_BND3(%rsp), %bnd3
+-	bndmov REGISTER_SAVE_BND2(%rsp), %bnd2
+-	bndmov REGISTER_SAVE_BND1(%rsp), %bnd1
+-	bndmov REGISTER_SAVE_BND0(%rsp), %bnd0
++	# Get register content back.
++# ifdef USE_FXSAVE
++	fxrstor STATE_SAVE_OFFSET(%rsp)
+ # else
+-	.byte 0x66,0x0f,0x1a,0x5c,0x24,REGISTER_SAVE_BND3
+-	.byte 0x66,0x0f,0x1a,0x54,0x24,REGISTER_SAVE_BND2
+-	.byte 0x66,0x0f,0x1a,0x4c,0x24,REGISTER_SAVE_BND1
+-#  if REGISTER_SAVE_BND0 == 0
+-	.byte 0x66,0x0f,0x1a,0x04,0x24
+-#  else
+-	.byte 0x66,0x0f,0x1a,0x44,0x24,REGISTER_SAVE_BND0
+-#  endif
++	movl $STATE_SAVE_MASK, %eax
++	xorl %edx, %edx
++	xrstor STATE_SAVE_OFFSET(%rsp)
+ # endif
+-#endif
+-	# Get register content back.
+ 	movq REGISTER_SAVE_R9(%rsp), %r9
+ 	movq REGISTER_SAVE_R8(%rsp), %r8
+ 	movq REGISTER_SAVE_RDI(%rsp), %rdi
+@@ -138,20 +139,12 @@ _dl_runtime_resolve:
+ 	movq REGISTER_SAVE_RDX(%rsp), %rdx
+ 	movq REGISTER_SAVE_RCX(%rsp), %rcx
+ 	movq REGISTER_SAVE_RAX(%rsp), %rax
+-	VMOV (REGISTER_SAVE_VEC_OFF)(%rsp), %VEC(0)
+-	VMOV (REGISTER_SAVE_VEC_OFF + VEC_SIZE)(%rsp), %VEC(1)
+-	VMOV (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 2)(%rsp), %VEC(2)
+-	VMOV (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 3)(%rsp), %VEC(3)
+-	VMOV (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 4)(%rsp), %VEC(4)
+-	VMOV (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 5)(%rsp), %VEC(5)
+-	VMOV (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 6)(%rsp), %VEC(6)
+-	VMOV (REGISTER_SAVE_VEC_OFF + VEC_SIZE * 7)(%rsp), %VEC(7)
+-#if DL_RUNTIME_RESOLVE_REALIGN_STACK
++# if DL_RUNTIME_RESOLVE_REALIGN_STACK
+ 	mov %RBX_LP, %RSP_LP
+ 	cfi_def_cfa_register(%rsp)
+ 	movq (%rsp), %rbx
+ 	cfi_restore(%rbx)
+-#endif
++# endif
+ 	# Adjust stack(PLT did 2 pushes)
+ 	add $(LOCAL_STORAGE_AREA + 16), %RSP_LP
+ 	cfi_adjust_cfa_offset(-(LOCAL_STORAGE_AREA + 16))
+@@ -160,9 +153,10 @@ _dl_runtime_resolve:
+ 	jmp *%r11		# Jump to function address.
+ 	cfi_endproc
+ 	.size _dl_runtime_resolve, .-_dl_runtime_resolve
++#endif
+ 
+ 
+-#ifndef PROF
++#if !defined PROF && defined _dl_runtime_profile
+ # if (LR_VECTOR_OFFSET % VEC_SIZE) != 0
+ #  error LR_VECTOR_OFFSET must be multples of VEC_SIZE
+ # endif
+diff --git a/sysdeps/x86_64/memcpy_chk.S b/sysdeps/x86_64/memcpy_chk.S
+index 2296b55119..a95b3ad3cf 100644
+--- a/sysdeps/x86_64/memcpy_chk.S
++++ b/sysdeps/x86_64/memcpy_chk.S
+@@ -19,7 +19,7 @@
+ #include <sysdep.h>
+ #include "asm-syntax.h"
+ 
+-#ifndef PIC
++#ifndef SHARED
+ 	/* For libc.so this is defined in memcpy.S.
+ 	   For libc.a, this is a separate source to avoid
+ 	   memcpy bringing in __chk_fail and all routines
+diff --git a/sysdeps/x86_64/multiarch/memcpy.S b/sysdeps/x86_64/multiarch/memcpy.S
+index b8677596f9..ea4ec70d1a 100644
+--- a/sysdeps/x86_64/multiarch/memcpy.S
++++ b/sysdeps/x86_64/multiarch/memcpy.S
+@@ -32,6 +32,8 @@ ENTRY(__new_memcpy)
+ 	lea	__memcpy_erms(%rip), %RAX_LP
+ 	HAS_ARCH_FEATURE (Prefer_ERMS)
+ 	jnz	2f
++	HAS_ARCH_FEATURE (Prefer_No_AVX512)
++	jnz	1f
+ 	HAS_ARCH_FEATURE (AVX512F_Usable)
+ 	jz	1f
+ 	lea	__memcpy_avx512_no_vzeroupper(%rip), %RAX_LP
+diff --git a/sysdeps/x86_64/multiarch/memcpy_chk.S b/sysdeps/x86_64/multiarch/memcpy_chk.S
+index 9d92c8a7e3..26b49de6f6 100644
+--- a/sysdeps/x86_64/multiarch/memcpy_chk.S
++++ b/sysdeps/x86_64/multiarch/memcpy_chk.S
+@@ -30,6 +30,8 @@
+ ENTRY(__memcpy_chk)
+ 	.type	__memcpy_chk, @gnu_indirect_function
+ 	LOAD_RTLD_GLOBAL_RO_RDX
++	HAS_ARCH_FEATURE (Prefer_No_AVX512)
++	jnz	1f
+ 	HAS_ARCH_FEATURE (AVX512F_Usable)
+ 	jz	1f
+ 	lea	__memcpy_chk_avx512_no_vzeroupper(%rip), %RAX_LP
+diff --git a/sysdeps/x86_64/multiarch/memmove.S b/sysdeps/x86_64/multiarch/memmove.S
+index ff5e041420..ef92afde5a 100644
+--- a/sysdeps/x86_64/multiarch/memmove.S
++++ b/sysdeps/x86_64/multiarch/memmove.S
+@@ -30,6 +30,8 @@ ENTRY(__libc_memmove)
+ 	lea	__memmove_erms(%rip), %RAX_LP
+ 	HAS_ARCH_FEATURE (Prefer_ERMS)
+ 	jnz	2f
++	HAS_ARCH_FEATURE (Prefer_No_AVX512)
++	jnz	1f
+ 	HAS_ARCH_FEATURE (AVX512F_Usable)
+ 	jz	1f
+ 	lea	__memmove_avx512_no_vzeroupper(%rip), %RAX_LP
+diff --git a/sysdeps/x86_64/multiarch/memmove_chk.S b/sysdeps/x86_64/multiarch/memmove_chk.S
+index 7f861206df..a9129c460a 100644
+--- a/sysdeps/x86_64/multiarch/memmove_chk.S
++++ b/sysdeps/x86_64/multiarch/memmove_chk.S
+@@ -29,6 +29,8 @@
+ ENTRY(__memmove_chk)
+ 	.type	__memmove_chk, @gnu_indirect_function
+ 	LOAD_RTLD_GLOBAL_RO_RDX
++	HAS_ARCH_FEATURE (Prefer_No_AVX512)
++	jnz	1f
+ 	HAS_ARCH_FEATURE (AVX512F_Usable)
+ 	jz	1f
+ 	lea	__memmove_chk_avx512_no_vzeroupper(%rip), %RAX_LP
+diff --git a/sysdeps/x86_64/multiarch/mempcpy.S b/sysdeps/x86_64/multiarch/mempcpy.S
+index 51970687cf..87c8299fea 100644
+--- a/sysdeps/x86_64/multiarch/mempcpy.S
++++ b/sysdeps/x86_64/multiarch/mempcpy.S
+@@ -32,6 +32,8 @@ ENTRY(__mempcpy)
+ 	lea	__mempcpy_erms(%rip), %RAX_LP
+ 	HAS_ARCH_FEATURE (Prefer_ERMS)
+ 	jnz	2f
++	HAS_ARCH_FEATURE (Prefer_No_AVX512)
++	jnz	1f
+ 	HAS_ARCH_FEATURE (AVX512F_Usable)
+ 	jz	1f
+ 	lea	__mempcpy_avx512_no_vzeroupper(%rip), %RAX_LP
+diff --git a/sysdeps/x86_64/multiarch/mempcpy_chk.S b/sysdeps/x86_64/multiarch/mempcpy_chk.S
+index 9e49f6f26e..642c67973b 100644
+--- a/sysdeps/x86_64/multiarch/mempcpy_chk.S
++++ b/sysdeps/x86_64/multiarch/mempcpy_chk.S
+@@ -30,6 +30,8 @@
+ ENTRY(__mempcpy_chk)
+ 	.type	__mempcpy_chk, @gnu_indirect_function
+ 	LOAD_RTLD_GLOBAL_RO_RDX
++	HAS_ARCH_FEATURE (Prefer_No_AVX512)
++	jnz	1f
+ 	HAS_ARCH_FEATURE (AVX512F_Usable)
+ 	jz	1f
+ 	lea	__mempcpy_chk_avx512_no_vzeroupper(%rip), %RAX_LP
+diff --git a/sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S b/sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S
+index 28e71fd576..acf448c9a6 100644
+--- a/sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S
++++ b/sysdeps/x86_64/multiarch/memset-vec-unaligned-erms.S
+@@ -110,6 +110,8 @@ ENTRY (__memset_erms)
+ ENTRY (MEMSET_SYMBOL (__memset, erms))
+ # endif
+ L(stosb):
++	/* Issue vzeroupper before rep stosb.  */
++	VZEROUPPER
+ 	movq	%rdx, %rcx
+ 	movzbl	%sil, %eax
+ 	movq	%rdi, %rdx
+diff --git a/sysdeps/x86_64/multiarch/memset.S b/sysdeps/x86_64/multiarch/memset.S
+index 96e99341aa..eae39e2ecd 100644
+--- a/sysdeps/x86_64/multiarch/memset.S
++++ b/sysdeps/x86_64/multiarch/memset.S
+@@ -41,6 +41,8 @@ ENTRY(memset)
+ 	jnz	L(AVX512F)
+ 	lea	__memset_avx2_unaligned(%rip), %RAX_LP
+ L(AVX512F):
++	HAS_ARCH_FEATURE (Prefer_No_AVX512)
++	jnz	2f
+ 	HAS_ARCH_FEATURE (AVX512F_Usable)
+ 	jz	2f
+ 	lea	__memset_avx512_no_vzeroupper(%rip), %RAX_LP
+diff --git a/sysdeps/x86_64/multiarch/memset_chk.S b/sysdeps/x86_64/multiarch/memset_chk.S
+index 2efe6ed909..38d7bef6df 100644
+--- a/sysdeps/x86_64/multiarch/memset_chk.S
++++ b/sysdeps/x86_64/multiarch/memset_chk.S
+@@ -38,6 +38,8 @@ ENTRY(__memset_chk)
+ 	jnz	L(AVX512F)
+ 	lea	__memset_chk_avx2_unaligned(%rip), %RAX_LP
+ L(AVX512F):
++	HAS_ARCH_FEATURE (Prefer_No_AVX512)
++	jnz	2f
+ 	HAS_ARCH_FEATURE (AVX512F_Usable)
+ 	jz	2f
+ 	lea	__memset_chk_avx512_no_vzeroupper(%rip), %RAX_LP
+diff --git a/sysdeps/x86_64/nptl/tcb-offsets.sym b/sysdeps/x86_64/nptl/tcb-offsets.sym
+index aeb752673a..8a25c482cb 100644
+--- a/sysdeps/x86_64/nptl/tcb-offsets.sym
++++ b/sysdeps/x86_64/nptl/tcb-offsets.sym
+@@ -4,7 +4,6 @@
+ 
+ RESULT			offsetof (struct pthread, result)
+ TID			offsetof (struct pthread, tid)
+-PID			offsetof (struct pthread, pid)
+ CANCELHANDLING		offsetof (struct pthread, cancelhandling)
+ CLEANUP_JMP_BUF		offsetof (struct pthread, cleanup_jmp_buf)
+ CLEANUP			offsetof (struct pthread, cleanup)
+diff --git a/sysdeps/x86_64/rtld-offsets.sym b/sysdeps/x86_64/rtld-offsets.sym
+new file mode 100644
+index 0000000000..fd41b51521
+--- /dev/null
++++ b/sysdeps/x86_64/rtld-offsets.sym
+@@ -0,0 +1,6 @@
++#define SHARED
++#include <ldsodefs.h>
++
++--
++
++GL_TLS_GENERATION_OFFSET        offsetof (struct rtld_global, _dl_tls_generation)
+diff --git a/sysdeps/x86_64/sysdep.h b/sysdeps/x86_64/sysdep.h
+index 75ac747be8..4b67fa80c1 100644
+--- a/sysdeps/x86_64/sysdep.h
++++ b/sysdeps/x86_64/sysdep.h
+@@ -89,13 +89,14 @@ lose:									      \
+   END (name)
+ 
+ #undef JUMPTARGET
+-#ifdef PIC
++#ifdef SHARED
+ # ifdef BIND_NOW
+ #  define JUMPTARGET(name)	*name##@GOTPCREL(%rip)
+ # else
+ #  define JUMPTARGET(name)	name##@PLT
+ # endif
+ #else
++/* For static archives, branch to target directly.  */
+ # define JUMPTARGET(name)	name
+ #endif
+ 
+diff --git a/sysdeps/x86_64/tls_get_addr.S b/sysdeps/x86_64/tls_get_addr.S
+new file mode 100644
+index 0000000000..9d38fb3be5
+--- /dev/null
++++ b/sysdeps/x86_64/tls_get_addr.S
+@@ -0,0 +1,61 @@
++/* Stack-aligning implementation of __tls_get_addr.  x86-64 version.
++   Copyright (C) 2017 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/>.  */
++
++#ifdef SHARED
++
++# include <sysdep.h>
++# include "tlsdesc.h"
++# include "rtld-offsets.h"
++
++/* See __tls_get_addr and __tls_get_addr_slow in dl-tls.c.  This function
++   call __tls_get_addr_slow on both slow paths.  It realigns the stack
++   before the call to work around GCC PR58066.  */
++
++ENTRY (__tls_get_addr)
++	mov 	%fs:DTV_OFFSET, %RDX_LP
++	mov	GL_TLS_GENERATION_OFFSET+_rtld_local(%rip), %RAX_LP
++	/* GL(dl_tls_generation) == dtv[0].counter */
++	cmp	%RAX_LP, (%rdx)
++	jne	1f
++	mov	TI_MODULE_OFFSET(%rdi), %RAX_LP
++	/* dtv[ti->ti_module] */
++# ifdef __LP64__
++	salq	$4, %rax
++	movq	(%rdx,%rax), %rax
++# else
++	movl	(%rdx,%rax, 8), %eax
++# endif
++	cmp	$-1, %RAX_LP
++	je	1f
++	add	TI_OFFSET_OFFSET(%rdi), %RAX_LP
++	ret
++1:
++	/* On the slow path, align the stack.  */
++	pushq	%rbp
++	cfi_def_cfa_offset (16)
++	cfi_offset (%rbp, -16)
++	mov	%RSP_LP, %RBP_LP
++	cfi_def_cfa_register (%rbp)
++	and	$-16, %RSP_LP
++	call	__tls_get_addr_slow
++	mov	%RBP_LP, %RSP_LP
++	popq	%rbp
++	cfi_def_cfa (%rsp, 8)
++	ret
++END (__tls_get_addr)
++#endif /* SHARED */
+diff --git a/sysdeps/x86_64/tlsdesc.sym b/sysdeps/x86_64/tlsdesc.sym
+index 33854975d0..fc897ab4b5 100644
+--- a/sysdeps/x86_64/tlsdesc.sym
++++ b/sysdeps/x86_64/tlsdesc.sym
+@@ -15,3 +15,6 @@ TLSDESC_ARG			offsetof(struct tlsdesc, arg)
+ TLSDESC_GEN_COUNT		offsetof(struct tlsdesc_dynamic_arg, gen_count)
+ TLSDESC_MODID			offsetof(struct tlsdesc_dynamic_arg, tlsinfo.ti_module)
+ TLSDESC_MODOFF			offsetof(struct tlsdesc_dynamic_arg, tlsinfo.ti_offset)
++
++TI_MODULE_OFFSET 		offsetof(tls_index, ti_module)
++TI_OFFSET_OFFSET 		offsetof(tls_index, ti_offset)
+diff --git a/sysdeps/x86_64/tst-avx-aux.c b/sysdeps/x86_64/tst-avx-aux.c
+new file mode 100644
+index 0000000000..e3807de7bb
+--- /dev/null
++++ b/sysdeps/x86_64/tst-avx-aux.c
+@@ -0,0 +1,47 @@
++/* Test case for preserved AVX registers in dynamic linker, -mavx part.
++   Copyright (C) 2017 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 <immintrin.h>
++#include <stdlib.h>
++#include <string.h>
++
++int
++tst_avx_aux (void)
++{
++#ifdef __AVX__
++  extern __m256i avx_test (__m256i, __m256i, __m256i, __m256i,
++			   __m256i, __m256i, __m256i, __m256i);
++
++  __m256i ymm0 = _mm256_set1_epi32 (0);
++  __m256i ymm1 = _mm256_set1_epi32 (1);
++  __m256i ymm2 = _mm256_set1_epi32 (2);
++  __m256i ymm3 = _mm256_set1_epi32 (3);
++  __m256i ymm4 = _mm256_set1_epi32 (4);
++  __m256i ymm5 = _mm256_set1_epi32 (5);
++  __m256i ymm6 = _mm256_set1_epi32 (6);
++  __m256i ymm7 = _mm256_set1_epi32 (7);
++  __m256i ret = avx_test (ymm0, ymm1, ymm2, ymm3,
++			  ymm4, ymm5, ymm6, ymm7);
++  ymm0 =  _mm256_set1_epi32 (0x12349876);
++  if (memcmp (&ymm0, &ret, sizeof (ret)))
++    abort ();
++  return 0;
++#else  /* __AVX__ */
++  return 77;
++#endif  /* __AVX__ */
++}
+diff --git a/sysdeps/x86_64/tst-avx.c b/sysdeps/x86_64/tst-avx.c
+new file mode 100644
+index 0000000000..ec2e3a79ff
+--- /dev/null
++++ b/sysdeps/x86_64/tst-avx.c
+@@ -0,0 +1,49 @@
++/* Test case for preserved AVX registers in dynamic linker.
++   Copyright (C) 2017 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 <cpuid.h>
++
++int tst_avx_aux (void);
++
++static int
++avx_enabled (void)
++{
++  unsigned int eax, ebx, ecx, edx;
++
++  if (__get_cpuid (1, &eax, &ebx, &ecx, &edx) == 0
++      || (ecx & (bit_AVX | bit_OSXSAVE)) != (bit_AVX | bit_OSXSAVE))
++    return 0;
++
++  /* Check the OS has AVX and SSE saving enabled.  */
++  asm ("xgetbv" : "=a" (eax), "=d" (edx) : "c" (0));
++
++  return (eax & 6) == 6;
++}
++
++static int
++do_test (void)
++{
++  /* Run AVX test only if AVX is supported.  */
++  if (avx_enabled ())
++    return tst_avx_aux ();
++  else
++    return 77;
++}
++
++#define TEST_FUNCTION do_test ()
++#include "../../test-skeleton.c"
+diff --git a/sysdeps/x86_64/tst-avx512-aux.c b/sysdeps/x86_64/tst-avx512-aux.c
+new file mode 100644
+index 0000000000..6cebc523f2
+--- /dev/null
++++ b/sysdeps/x86_64/tst-avx512-aux.c
+@@ -0,0 +1,48 @@
++/* Test case for preserved AVX512 registers in dynamic linker,
++   -mavx512 part.
++   Copyright (C) 2017 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 <immintrin.h>
++#include <stdlib.h>
++#include <string.h>
++
++int
++tst_avx512_aux (void)
++{
++#ifdef __AVX512F__
++  extern __m512i avx512_test (__m512i, __m512i, __m512i, __m512i,
++			      __m512i, __m512i, __m512i, __m512i);
++
++  __m512i zmm0 = _mm512_set1_epi32 (0);
++  __m512i zmm1 = _mm512_set1_epi32 (1);
++  __m512i zmm2 = _mm512_set1_epi32 (2);
++  __m512i zmm3 = _mm512_set1_epi32 (3);
++  __m512i zmm4 = _mm512_set1_epi32 (4);
++  __m512i zmm5 = _mm512_set1_epi32 (5);
++  __m512i zmm6 = _mm512_set1_epi32 (6);
++  __m512i zmm7 = _mm512_set1_epi32 (7);
++  __m512i ret = avx512_test (zmm0, zmm1, zmm2, zmm3,
++			     zmm4, zmm5, zmm6, zmm7);
++  zmm0 =  _mm512_set1_epi32 (0x12349876);
++  if (memcmp (&zmm0, &ret, sizeof (ret)))
++    abort ();
++  return 0;
++#else  /* __AVX512F__ */
++  return 77;
++#endif  /* __AVX512F__ */
++}
+diff --git a/sysdeps/x86_64/tst-avx512.c b/sysdeps/x86_64/tst-avx512.c
+new file mode 100644
+index 0000000000..a8e42ef553
+--- /dev/null
++++ b/sysdeps/x86_64/tst-avx512.c
+@@ -0,0 +1,57 @@
++/* Test case for preserved AVX512 registers in dynamic linker.
++   Copyright (C) 2017 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 <cpuid.h>
++
++int tst_avx512_aux (void);
++
++static int
++avx512_enabled (void)
++{
++#ifdef bit_AVX512F
++  unsigned int eax, ebx, ecx, edx;
++
++  if (__get_cpuid (1, &eax, &ebx, &ecx, &edx) == 0
++      || (ecx & (bit_AVX | bit_OSXSAVE)) != (bit_AVX | bit_OSXSAVE))
++    return 0;
++
++  __cpuid_count (7, 0, eax, ebx, ecx, edx);
++  if (!(ebx & bit_AVX512F))
++    return 0;
++
++  asm ("xgetbv" : "=a" (eax), "=d" (edx) : "c" (0));
++
++  /* Verify that ZMM, YMM and XMM states are enabled.  */
++  return (eax & 0xe6) == 0xe6;
++#else
++  return 0;
++#endif
++}
++
++static int
++do_test (void)
++{
++  /* Run AVX512 test only if AVX512 is supported.  */
++  if (avx512_enabled ())
++    return tst_avx512_aux ();
++  else
++    return 77;
++}
++
++#define TEST_FUNCTION do_test ()
++#include "../../test-skeleton.c"
+diff --git a/sysdeps/x86_64/tst-avx512mod.c b/sysdeps/x86_64/tst-avx512mod.c
+new file mode 100644
+index 0000000000..4cfb3a2c3d
+--- /dev/null
++++ b/sysdeps/x86_64/tst-avx512mod.c
+@@ -0,0 +1,48 @@
++/* Test case for x86-64 preserved AVX512 registers in dynamic linker.  */
++
++#ifdef __AVX512F__
++#include <stdlib.h>
++#include <string.h>
++#include <immintrin.h>
++
++__m512i
++avx512_test (__m512i x0, __m512i x1, __m512i x2, __m512i x3,
++	     __m512i x4, __m512i x5, __m512i x6, __m512i x7)
++{
++  __m512i zmm;
++
++  zmm = _mm512_set1_epi32 (0);
++  if (memcmp (&zmm, &x0, sizeof (zmm)))
++    abort ();
++
++  zmm = _mm512_set1_epi32 (1);
++  if (memcmp (&zmm, &x1, sizeof (zmm)))
++    abort ();
++
++  zmm = _mm512_set1_epi32 (2);
++  if (memcmp (&zmm, &x2, sizeof (zmm)))
++    abort ();
++
++  zmm = _mm512_set1_epi32 (3);
++  if (memcmp (&zmm, &x3, sizeof (zmm)))
++    abort ();
++
++  zmm = _mm512_set1_epi32 (4);
++  if (memcmp (&zmm, &x4, sizeof (zmm)))
++    abort ();
++
++  zmm = _mm512_set1_epi32 (5);
++  if (memcmp (&zmm, &x5, sizeof (zmm)))
++    abort ();
++
++  zmm = _mm512_set1_epi32 (6);
++  if (memcmp (&zmm, &x6, sizeof (zmm)))
++    abort ();
++
++  zmm = _mm512_set1_epi32 (7);
++  if (memcmp (&zmm, &x7, sizeof (zmm)))
++    abort ();
++
++  return _mm512_set1_epi32 (0x12349876);
++}
++#endif
+diff --git a/sysdeps/x86_64/tst-avxmod.c b/sysdeps/x86_64/tst-avxmod.c
+new file mode 100644
+index 0000000000..6e5b154997
+--- /dev/null
++++ b/sysdeps/x86_64/tst-avxmod.c
+@@ -0,0 +1,48 @@
++/* Test case for x86-64 preserved AVX registers in dynamic linker.  */
++
++#ifdef __AVX__
++#include <stdlib.h>
++#include <string.h>
++#include <immintrin.h>
++
++__m256i
++avx_test (__m256i x0, __m256i x1, __m256i x2, __m256i x3,
++	  __m256i x4, __m256i x5, __m256i x6, __m256i x7)
++{
++  __m256i ymm;
++
++  ymm = _mm256_set1_epi32 (0);
++  if (memcmp (&ymm, &x0, sizeof (ymm)))
++    abort ();
++
++  ymm = _mm256_set1_epi32 (1);
++  if (memcmp (&ymm, &x1, sizeof (ymm)))
++    abort ();
++
++  ymm = _mm256_set1_epi32 (2);
++  if (memcmp (&ymm, &x2, sizeof (ymm)))
++    abort ();
++
++  ymm = _mm256_set1_epi32 (3);
++  if (memcmp (&ymm, &x3, sizeof (ymm)))
++    abort ();
++
++  ymm = _mm256_set1_epi32 (4);
++  if (memcmp (&ymm, &x4, sizeof (ymm)))
++    abort ();
++
++  ymm = _mm256_set1_epi32 (5);
++  if (memcmp (&ymm, &x5, sizeof (ymm)))
++    abort ();
++
++  ymm = _mm256_set1_epi32 (6);
++  if (memcmp (&ymm, &x6, sizeof (ymm)))
++    abort ();
++
++  ymm = _mm256_set1_epi32 (7);
++  if (memcmp (&ymm, &x7, sizeof (ymm)))
++    abort ();
++
++  return _mm256_set1_epi32 (0x12349876);
++}
++#endif
+diff --git a/sysdeps/x86_64/tst-sse.c b/sysdeps/x86_64/tst-sse.c
+new file mode 100644
+index 0000000000..dd1537cf27
+--- /dev/null
++++ b/sysdeps/x86_64/tst-sse.c
+@@ -0,0 +1,46 @@
++/* Test case for preserved SSE registers in dynamic linker.
++   Copyright (C) 2017 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 <immintrin.h>
++#include <stdlib.h>
++#include <string.h>
++
++extern __m128i sse_test (__m128i, __m128i, __m128i, __m128i,
++			 __m128i, __m128i, __m128i, __m128i);
++
++static int
++do_test (void)
++{
++  __m128i xmm0 = _mm_set1_epi32 (0);
++  __m128i xmm1 = _mm_set1_epi32 (1);
++  __m128i xmm2 = _mm_set1_epi32 (2);
++  __m128i xmm3 = _mm_set1_epi32 (3);
++  __m128i xmm4 = _mm_set1_epi32 (4);
++  __m128i xmm5 = _mm_set1_epi32 (5);
++  __m128i xmm6 = _mm_set1_epi32 (6);
++  __m128i xmm7 = _mm_set1_epi32 (7);
++  __m128i ret = sse_test (xmm0, xmm1, xmm2, xmm3,
++			  xmm4, xmm5, xmm6, xmm7);
++  xmm0 =  _mm_set1_epi32 (0x12349876);
++  if (memcmp (&xmm0, &ret, sizeof (ret)))
++    abort ();
++  return 0;
++}
++
++#define TEST_FUNCTION do_test ()
++#include "../../test-skeleton.c"
+diff --git a/sysdeps/x86_64/tst-ssemod.c b/sysdeps/x86_64/tst-ssemod.c
+new file mode 100644
+index 0000000000..907a64c69e
+--- /dev/null
++++ b/sysdeps/x86_64/tst-ssemod.c
+@@ -0,0 +1,46 @@
++/* Test case for x86-64 preserved SSE registers in dynamic linker.  */
++
++#include <stdlib.h>
++#include <string.h>
++#include <immintrin.h>
++
++__m128i
++sse_test (__m128i x0, __m128i x1, __m128i x2, __m128i x3,
++	  __m128i x4, __m128i x5, __m128i x6, __m128i x7)
++{
++  __m128i xmm;
++
++  xmm = _mm_set1_epi32 (0);
++  if (memcmp (&xmm, &x0, sizeof (xmm)))
++    abort ();
++
++  xmm = _mm_set1_epi32 (1);
++  if (memcmp (&xmm, &x1, sizeof (xmm)))
++    abort ();
++
++  xmm = _mm_set1_epi32 (2);
++  if (memcmp (&xmm, &x2, sizeof (xmm)))
++    abort ();
++
++  xmm = _mm_set1_epi32 (3);
++  if (memcmp (&xmm, &x3, sizeof (xmm)))
++    abort ();
++
++  xmm = _mm_set1_epi32 (4);
++  if (memcmp (&xmm, &x4, sizeof (xmm)))
++    abort ();
++
++  xmm = _mm_set1_epi32 (5);
++  if (memcmp (&xmm, &x5, sizeof (xmm)))
++    abort ();
++
++  xmm = _mm_set1_epi32 (6);
++  if (memcmp (&xmm, &x6, sizeof (xmm)))
++    abort ();
++
++  xmm = _mm_set1_epi32 (7);
++  if (memcmp (&xmm, &x7, sizeof (xmm)))
++    abort ();
++
++  return _mm_set1_epi32 (0x12349876);
++}
diff --git a/glibc/iconv-gconv_trans.c.patch b/glibc/iconv-gconv_trans.c.patch
deleted file mode 100644
index 8aec86f..0000000
--- a/glibc/iconv-gconv_trans.c.patch
+++ /dev/null
@@ -1,192 +0,0 @@
-X-Git-Url: https://sourceware.org/git/gitweb.cgi?p=glibc.git;a=blobdiff_plain;f=iconv%2...
-
-diff --git a/iconv/gconv_trans.c b/iconv/gconv_trans.c
-index 1e25854..e0835fc 100644
---- a/iconv/gconv_trans.c
-+++ b/iconv/gconv_trans.c
-@@ -238,181 +238,12 @@ __gconv_transliterate (struct __gconv_step *step,
-   return __GCONV_ILLEGAL_INPUT;
- }
- 
--
--/* Structure to represent results of found (or not) transliteration
--   modules.  */
--struct known_trans
--{
--  /* This structure must remain the first member.  */
--  struct trans_struct info;
--
--  char *fname;
--  void *handle;
--  int open_count;
--};
--
--
--/* Tree with results of previous calls to __gconv_translit_find.  */
--static void *search_tree;
--
--/* We modify global data.   */
--__libc_lock_define_initialized (static, lock);
--
--
--/* Compare two transliteration entries.  */
--static int
--trans_compare (const void *p1, const void *p2)
--{
--  const struct known_trans *s1 = (const struct known_trans *) p1;
--  const struct known_trans *s2 = (const struct known_trans *) p2;
--
--  return strcmp (s1->info.name, s2->info.name);
--}
--
--
--/* Open (maybe reopen) the module named in the struct.  Get the function
--   and data structure pointers we need.  */
--static int
--open_translit (struct known_trans *trans)
--{
--  __gconv_trans_query_fct queryfct;
--
--  trans->handle = __libc_dlopen (trans->fname);
--  if (trans->handle == NULL)
--    /* Not available.  */
--    return 1;
--
--  /* Find the required symbol.  */
--  queryfct = __libc_dlsym (trans->handle, "gconv_trans_context");
--  if (queryfct == NULL)
--    {
--      /* We cannot live with that.  */
--    close_and_out:
--      __libc_dlclose (trans->handle);
--      trans->handle = NULL;
--      return 1;
--    }
--
--  /* Get the context.  */
--  if (queryfct (trans->info.name, &trans->info.csnames, &trans->info.ncsnames)
--      != 0)
--    goto close_and_out;
--
--  /* Of course we also have to have the actual function.  */
--  trans->info.trans_fct = __libc_dlsym (trans->handle, "gconv_trans");
--  if (trans->info.trans_fct == NULL)
--    goto close_and_out;
--
--  /* Now the optional functions.  */
--  trans->info.trans_init_fct =
--    __libc_dlsym (trans->handle, "gconv_trans_init");
--  trans->info.trans_context_fct =
--    __libc_dlsym (trans->handle, "gconv_trans_context");
--  trans->info.trans_end_fct =
--    __libc_dlsym (trans->handle, "gconv_trans_end");
--
--  trans->open_count = 1;
--
--  return 0;
--}
--
--
- int
- internal_function
- __gconv_translit_find (struct trans_struct *trans)
- {
--  struct known_trans **found;
--  const struct path_elem *runp;
--  int res = 1;
--
--  /* We have to have a name.  */
--  assert (trans->name != NULL);
--
--  /* Acquire the lock.  */
--  __libc_lock_lock (lock);
--
--  /* See whether we know this module already.  */
--  found = __tfind (trans, &search_tree, trans_compare);
--  if (found != NULL)
--    {
--      /* Is this module available?  */
--      if ((*found)->handle != NULL)
--	{
--	  /* Maybe we have to reopen the file.  */
--	  if ((*found)->handle != (void *) -1)
--	    /* The object is not unloaded.  */
--	    res = 0;
--	  else if (open_translit (*found) == 0)
--	    {
--	      /* Copy the data.  */
--	      *trans = (*found)->info;
--	      (*found)->open_count++;
--	      res = 0;
--	    }
--	}
--    }
--  else
--    {
--      size_t name_len = strlen (trans->name) + 1;
--      int need_so = 0;
--      struct known_trans *newp;
--
--      /* We have to continue looking for the module.  */
--      if (__gconv_path_elem == NULL)
--	__gconv_get_path ();
--
--      /* See whether we have to append .so.  */
--      if (name_len <= 4 || memcmp (&trans->name[name_len - 4], ".so", 3) != 0)
--	need_so = 1;
--
--      /* Create a new entry.  */
--      newp = (struct known_trans *) malloc (sizeof (struct known_trans)
--					    + (__gconv_max_path_elem_len
--					       + name_len + 3)
--					    + name_len);
--      if (newp != NULL)
--	{
--	  char *cp;
--
--	  /* Clear the struct.  */
--	  memset (newp, '\0', sizeof (struct known_trans));
--
--	  /* Store a copy of the module name.  */
--	  newp->info.name = cp = (char *) (newp + 1);
--	  cp = __mempcpy (cp, trans->name, name_len);
--
--	  newp->fname = cp;
--
--	  /* Search in all the directories.  */
--	  for (runp = __gconv_path_elem; runp->name != NULL; ++runp)
--	    {
--	      cp = __mempcpy (__stpcpy ((char *) newp->fname, runp->name),
--			      trans->name, name_len);
--	      if (need_so)
--		memcpy (cp, ".so", sizeof (".so"));
--
--	      if (open_translit (newp) == 0)
--		{
--		  /* We found a module.  */
--		  res = 0;
--		  break;
--		}
--	    }
--
--	  if (res)
--	    newp->fname = NULL;
--
--	  /* In any case we'll add the entry to our search tree.  */
--	  if (__tsearch (newp, &search_tree, trans_compare) == NULL)
--	    {
--	      /* Yickes, this should not happen.  Unload the object.  */
--	      res = 1;
--	      /* XXX unload here.  */
--	    }
--	}
--    }
--
--  __libc_lock_unlock (lock);
--
--  return res;
-+  /* Transliteration module loading has been removed because it never
-+     worked as intended and suffered from a security vulnerability.
-+     Consequently, this function always fails.  */
-+  return 1;
- }
-- 
2.15.1

...
_______________________________________________
crux-arm mailing list
crux-arm@crux-arm.nu
https://crux-arm.nu/mailman/listinfo/crux-arm
Regards,

---
Victor Martinez
Learning bit by bit | http://vjml.es

    