[PATCH v2 00/20] aarch64-gnu port & GNU/Hurd on AArch64 progress

[PATCH v2 00/20] aarch64-gnu port & GNU/Hurd on AArch64 progress

[Sergey Bugaev]

Hello!

This is v2 of my work on the aarch64-gnu port, aka GNU/Hurd on 64-bit
ARM. v1 is here [0].

[0]: https://sourceware.org/pipermail/libc-alpha/2024-January/153675.html

Last time, Joseph Myers has pointed out that the aarch64-gnu port can
not be merged into glibc until aarch64-gnu support is upstream in all of
glibc's build-time dependencies. That is still not the case, so this
patchset can not be merged yet; but otherwise it should be in a fairly
mergeable state. It does not yet anything to NEWS or
build-many-glibcs.py, though.

I'm porting this, again, to gather some feedback (hopefully more than
last time...), and at Maxim's request, so Linaro can test this on their
CI and ensure this doesn't break existing ports.

The upstreaming status of various aarch64-gnu components is,
specifically:

* Binutils patch to add the aarch64-gnu target is upstream and in the
  2.42 release;
* GCC patches to add aarch64-gnu target (& libgcc host) have been
  reviewed by ARM and Hurd port maintainers and should land upstream
  very soon;
* initial Hurd patches are upstream;
* glibc patches (this patchset) are not yet upstream;
* GNU Mach changes are not upstream, and upstreaming story is unclear;
* GNU MIG needs no changes, it just works.

Last time, there was no AArch64 port of GNU Mach, and so the only
testing I have done was running a simple statically-linked executable on
Linux under GDB -- which, nevertheless, helped me identify and fix a
number of issues.

Since then, however, I have been (some may say, relentlessly) working on
filling in the missing piece, namely porting gnumach (with important
help & contributions by Luca D.). I am happy to report that we now have
an experimental port of gnumach that builds and works on AArch64! While
that may sound impressive, note that various things about it are in an
extremely basic, proof-of-concept state rather than being seriously
production-ready; and also that Mach is a small kernel (indeed, a
microkernel), and it was designed from the start (back in the 80s) to be
portable, so most of the "buisness logic" functionality (virtual memory,
IPC, tasks/threads/scheduler) is explicitly arch-independent.

Despite the scary "WIP proof-of-concept" status, there is enough
functionality in Mach to run userland code, handle exceptions and
syscalls, interact with the MMU to implement all the expected virtual
memory semantics, schedule/switch tasks and threads, and so on.
Moreover, all of gnumach's userspace self-tests pass!

This meant there was enough things in place for me to try running glibc
on it, and the amazing thing is my simple test executable, the same one
I previously tested on Linux w/ GDB, just worked on real Mach without me
having to make any additional changes to the glibc side, or even
recompile it.

But I did not stop there, and got several of the core Hurd servers
working! Namely, these are ext2fs, exec, startup, auth, and proc
servers. All of them but ext2fs are dynamically linked; ld-aarch64.so.1
sucessfully locates and maps the programs themselves and their required
dependencies, and Mach pages in code and data pages from ext2fs as they
are accessed, transparently to the program, just as one would expect it
to.

It turned out that Mach on i386 and x86_64 did not enforce the (lack of)
execute permission on pages, i.e. even pages mapped without
VM_PROT_EXECUTE were executable in practice. This caused a number of
bugs related to mapping executable stacks to go unnoticed, there were
issues in all of Mach, glibc, and the Hurd's exec server related to
not creating executable stacks as actually executable. As I implemented
the execute permission properly in Mach on AArch64 (indeed, I even
support execute-only pages when the hardware implements FEAT_EPAN), I
have encountered all of those oversights one by one when trying to run
progressively more code, and have hopefully fixed them all. Hopefully
we'll stop requiring executable stacks for glibc and Hurd libraries some
time, and then we'll get working non-executable stacks on AArch64.

As expected, I have done some tweaks to the AArch64-specific Mach APIs
(primarily thread state and exception code definitions) compared to the
"preliminary sketches" of them that I posted in January, but they were
actually rather small. I've got some more confidence in the APIs now
after having implemented support for them from both sides now, and
having tested that it works in practice. No more backwards-incompatible
changes to AArch64-specific Mach APIs are expected (by me anyway); we'll
definetely want to add more things later (aarch64_debug_state for GDB,
PAC RPCs, and more), but those should be purely additive.

I have added a new Mach syscall (trap), thread_set_self_state (), to
implement sigreturn () on top of. I have originally hoped that it would
be possible to use the regular thread_set_state (mach_thread_self ())
call for it (special-casing it on AArch64 to allow setting the calling
thread's state), and indeed have initially implemented that on the Mach
side. I have then realized that this would cause a number of annoying
issues (there are good reasons why Mach doesn't allow one to call
thread_set_state () on the calling thread) that can be elegantly avoided
by making it into a dedicated syscall that is explicitly not an RPC.
Please see the explanation in the gnumach patch adding the syscall for a
more detailed explanation -- once I write that explanation and post that
patch, that is.

The new syscall (same as the potential RPC version of it), however, is a
security concern, much like sigreturn is in general: it makes it
feasible for attackers to use sigreturn-oriented programming (SROP)
tricks. Linux has, allegedly, mitigated SROP by placing a magic cookie
on the user stack next to (or inside) sigcontext, and later verifying it
in sigreturn () -- although I failed to find the code responsible for
implementing that in the Linux source tree, at least not in AArch64-
specific signal implementation. In any case, this approach is not
feasible for Mach, since Mach is not involved in placing the sigcontext
(nor the thread state structure) on user's stack. Suggestions on what to
do about this (including convincing me that this is OK and we don't have
to do anything about it, given that we have executable stacks...) are
very welcome.

But security concerns notwithstanding, I managed to test the signal
handling code path in practice, and it does work! (Indeed, it just
worked on the first try; somehow I got everything right.) The signal-
raising RPC gets received by the signal thread, the target thread
aborted inside _hurd_intr_rpc_mach_msg (), its state fetched and
modified to jump to the signal trampoline, then resumed; from the
trampoline, it calls the user's handler as expected, and then calls
sigreturn (), which uses thread_set_self_state (), resetting itself to
continue right from where it got interrupted, and continues from there;
it all works!

Besides core Hurd servers, I have tested a simple Unix program running
as PID 1 on the resulting system (with a proc port and a singal thread,
as described above, and all the other state). Among the things I tested
is fork () + wait (), and (with the latest fixes on the gnumach side)
this now totally works as well.

Sergey

[PATCH v2 01/20] hurd: Move internal functions to internal header

[Sergey Bugaev]

Move _hurd_self_sigstate (), _hurd_critical_section_lock (), and
_hurd_critical_section_unlock () inline implementations (that were
already guarded by #if defined _LIBC) to the internal version of the
header.  While at it, add <tls.h> to the includes, and use
__LIBC_NO_TLS () unconditionally.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---

This is the remaining part of the "hurd: Add some missing includes"
patch from v1, redone in a different way, as discussed last time.

The hurd/check-installed-headers-c test seems to pass for me, but please
check on your end too.

 hurd/hurd/signal.h                 | 87 ------------------------------
 sysdeps/hurd/include/hurd/signal.h | 78 +++++++++++++++++++++++++++
 2 files changed, 78 insertions(+), 87 deletions(-)

diff --git a/hurd/hurd/signal.h b/hurd/hurd/signal.h
index 6bc7103b..5d116fb2 100644
--- a/hurd/hurd/signal.h
+++ b/hurd/hurd/signal.h
@@ -40,11 +40,6 @@
 #include <setjmp.h>		/* For `jmp_buf'.  */
 #include <spin-lock.h>
 struct hurd_signal_preemptor;	/* <hurd/sigpreempt.h> */
-#if defined __USE_EXTERN_INLINES && defined _LIBC
-# if IS_IN (libc) || IS_IN (libpthread)
-#  include <sigsetops.h>
-# endif
-#endif
 
 
 /* Full details of a signal.  */
@@ -157,33 +152,6 @@ extern void _hurd_sigstate_unlock (struct hurd_sigstate *ss);
 /* Used by libpthread to remove stale sigstate structures.  */
 extern void _hurd_sigstate_delete (thread_t thread);
 
-#ifndef _HURD_SIGNAL_H_EXTERN_INLINE
-#define _HURD_SIGNAL_H_EXTERN_INLINE __extern_inline
-#endif
-
-#if defined __USE_EXTERN_INLINES && defined _LIBC
-# if IS_IN (libc)
-_HURD_SIGNAL_H_EXTERN_INLINE struct hurd_sigstate *
-_hurd_self_sigstate (void)
-{
-  struct hurd_sigstate *ss = THREAD_GETMEM (THREAD_SELF, _hurd_sigstate);
-  if (__glibc_unlikely (ss == NULL))
-    {
-      thread_t self = __mach_thread_self ();
-
-      /* The thread variable is unset; this must be the first time we've
-        asked for it.  In this case, the critical section flag cannot
-        possible already be set.  Look up our sigstate structure the slow
-        way.  */
-      ss = _hurd_thread_sigstate (self);
-      THREAD_SETMEM (THREAD_SELF, _hurd_sigstate, ss);
-      __mach_port_deallocate (__mach_task_self (), self);
-    }
-  return ss;
-}
-# endif
-#endif
-
 struct machine_thread_all_state;
 extern mach_port_t
 _hurdsig_abort_rpcs (struct hurd_sigstate *ss, int signo, int sigthread,
@@ -215,63 +183,8 @@ extern int _hurd_core_limit;
    avoid unexpectingly exposing EINTR to the application.  */
 
 extern void *_hurd_critical_section_lock (void);
-
-#if defined __USE_EXTERN_INLINES && defined _LIBC
-# if IS_IN (libc)
-_HURD_SIGNAL_H_EXTERN_INLINE void *
-_hurd_critical_section_lock (void)
-{
-  struct hurd_sigstate *ss;
-
-#ifdef __LIBC_NO_TLS
-  if (__LIBC_NO_TLS ())
-    /* TLS is currently initializing, no need to enter critical section.  */
-    return NULL;
-#endif
-
-  ss = _hurd_self_sigstate ();
-
-  if (! __spin_try_lock (&ss->critical_section_lock))
-    /* We are already in a critical section, so do nothing.  */
-    return NULL;
-
-  /* With the critical section lock held no signal handler will run.
-     Return our sigstate pointer; this will be passed to
-     _hurd_critical_section_unlock to unlock it.  */
-  return ss;
-}
-# endif
-#endif
-
 extern void _hurd_critical_section_unlock (void *our_lock);
 
-#if defined __USE_EXTERN_INLINES && defined _LIBC
-# if IS_IN (libc)
-_HURD_SIGNAL_H_EXTERN_INLINE void
-_hurd_critical_section_unlock (void *our_lock)
-{
-  if (our_lock == NULL)
-    /* The critical section lock was held when we began.  Do nothing.  */
-    return;
-  else
-    {
-      /* It was us who acquired the critical section lock.  Unlock it.  */
-      struct hurd_sigstate *ss = (struct hurd_sigstate *) our_lock;
-      sigset_t pending;
-      _hurd_sigstate_lock (ss);
-      __spin_unlock (&ss->critical_section_lock);
-      pending = _hurd_sigstate_pending (ss) & ~ss->blocked;
-      _hurd_sigstate_unlock (ss);
-      if (__glibc_unlikely (!__sigisemptyset (&pending)))
-	/* There are unblocked signals pending, which weren't
-	   delivered because we were in the critical section.
-	   Tell the signal thread to deliver them now.  */
-	__msg_sig_post (_hurd_msgport, 0, 0, __mach_task_self ());
-    }
-}
-# endif
-#endif
-
 /* Convenient macros for simple uses of critical sections.
    These two must be used as a pair at the same C scoping level.  */
 
diff --git a/sysdeps/hurd/include/hurd/signal.h b/sysdeps/hurd/include/hurd/signal.h
index 1dc8a1f3..fab8d1b6 100644
--- a/sysdeps/hurd/include/hurd/signal.h
+++ b/sysdeps/hurd/include/hurd/signal.h
@@ -9,6 +9,84 @@ libc_hidden_proto (_hurd_self_sigstate)
 #include_next <hurd/signal.h>
 
 #ifndef _ISOMAC
+
+#if defined __USE_EXTERN_INLINES
+# if IS_IN (libc) || IS_IN (libpthread)
+#  include <sigsetops.h>
+#  include <tls.h>
+# endif
+#endif
+
+#ifndef _HURD_SIGNAL_H_EXTERN_INLINE
+#define _HURD_SIGNAL_H_EXTERN_INLINE __extern_inline
+#endif
+
+#if defined __USE_EXTERN_INLINES && IS_IN (libc)
+_HURD_SIGNAL_H_EXTERN_INLINE struct hurd_sigstate *
+_hurd_self_sigstate (void)
+{
+  struct hurd_sigstate *ss = THREAD_GETMEM (THREAD_SELF, _hurd_sigstate);
+  if (__glibc_unlikely (ss == NULL))
+    {
+      thread_t self = __mach_thread_self ();
+
+      /* The thread variable is unset; this must be the first time we've
+        asked for it.  In this case, the critical section flag cannot
+        possible already be set.  Look up our sigstate structure the slow
+        way.  */
+      ss = _hurd_thread_sigstate (self);
+      THREAD_SETMEM (THREAD_SELF, _hurd_sigstate, ss);
+      __mach_port_deallocate (__mach_task_self (), self);
+    }
+  return ss;
+}
+
+_HURD_SIGNAL_H_EXTERN_INLINE void *
+_hurd_critical_section_lock (void)
+{
+  struct hurd_sigstate *ss;
+
+  if (__LIBC_NO_TLS ())
+    /* TLS is currently initializing, no need to enter critical section.  */
+    return NULL;
+
+  ss = _hurd_self_sigstate ();
+
+  if (! __spin_try_lock (&ss->critical_section_lock))
+    /* We are already in a critical section, so do nothing.  */
+    return NULL;
+
+  /* With the critical section lock held no signal handler will run.
+     Return our sigstate pointer; this will be passed to
+     _hurd_critical_section_unlock to unlock it.  */
+  return ss;
+}
+
+_HURD_SIGNAL_H_EXTERN_INLINE void
+_hurd_critical_section_unlock (void *our_lock)
+{
+  if (our_lock == NULL)
+    /* The critical section lock was held when we began.  Do nothing.  */
+    return;
+  else
+    {
+      /* It was us who acquired the critical section lock.  Unlock it.  */
+      struct hurd_sigstate *ss = (struct hurd_sigstate *) our_lock;
+      sigset_t pending;
+      _hurd_sigstate_lock (ss);
+      __spin_unlock (&ss->critical_section_lock);
+      pending = _hurd_sigstate_pending (ss) & ~ss->blocked;
+      _hurd_sigstate_unlock (ss);
+      if (__glibc_unlikely (!__sigisemptyset (&pending)))
+	/* There are unblocked signals pending, which weren't
+	   delivered because we were in the critical section.
+	   Tell the signal thread to deliver them now.  */
+	__msg_sig_post (_hurd_msgport, 0, 0, __mach_task_self ());
+    }
+}
+#endif /* defined __USE_EXTERN_INLINES && IS_IN (libc) */
+
+
 libc_hidden_proto (_hurd_exception2signal)
 libc_hidden_proto (_hurd_intr_rpc_mach_msg)
 libc_hidden_proto (_hurd_thread_sigstate)
-- 
2.44.0

[PATCH v2 02/20] hurd: Stop relying on VM_MAX_ADDRESS

[Sergey Bugaev]

We'd like to avoid committing to a specific size of virtual address
space (i.e. the value of VM_AARCH64_T0SZ) on AArch64.  While the current
version of GNU Mach still exports VM_MAX_ADDRESS for compatibility, we
should try to avoid relying on it when we can.  This piece of logic in
_hurdsig_getenv () doesn't actually care about the size of user-
accessible virtual address space, it just wants to preempt faults on any
addresses starting from the value of the P pointer and above.  So, use
(unsigned long int) -1 instead of VM_MAX_ADDRESS.

While at it, change the casts to (unsigned long int) and not just
(long int), since the type of struct hurd_signal_preemptor.{first,last}
is unsigned long int.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 hurd/hurdsig.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/hurd/hurdsig.c b/hurd/hurdsig.c
index 882a0347..8b1928d1 100644
--- a/hurd/hurdsig.c
+++ b/hurd/hurdsig.c
@@ -1658,8 +1658,8 @@ _hurdsig_getenv (const char *variable)
       while (*ep)
 	{
 	  const char *p = *ep;
-	  _hurdsig_fault_preemptor.first = (long int) p;
-	  _hurdsig_fault_preemptor.last = VM_MAX_ADDRESS;
+	  _hurdsig_fault_preemptor.first = (unsigned long int) p;
+	  _hurdsig_fault_preemptor.last = (unsigned long int) -1;
 	  if (! strncmp (p, variable, len) && p[len] == '=')
 	    {
 	      size_t valuelen;
@@ -1671,8 +1671,8 @@ _hurdsig_getenv (const char *variable)
 		memcpy (value, p, valuelen);
 	      break;
 	    }
-	  _hurdsig_fault_preemptor.first = (long int) ++ep;
-	  _hurdsig_fault_preemptor.last = (long int) (ep + 1);
+	  _hurdsig_fault_preemptor.first = (unsigned long int) ++ep;
+	  _hurdsig_fault_preemptor.last = (unsigned long int) (ep + 1);
 	}
       _hurdsig_end_catch_fault ();
       return value;
-- 
2.44.0

[PATCH v2 03/20] Allow glibc to be compiled without EXEC_PAGESIZE

[Sergey Bugaev]

We would like to avoid statically defining any specific page size on
aarch64-gnu, and instead make sure that everything uses the dynamic
page size, available via vm_page_size and GLRO(dl_pagesize).

There are currently a few places in glibc that require EXEC_PAGESIZE
to be defined. Per Roland's suggestion [0], drop the static
GLRO(dl_pagesize) initializers (for now, only if EXEC_PAGESIZE is not
defined), and don't require EXEC_PAGESIZE definition for libio to
enable mmap usage.

[0]: https://mail.gnu.org/archive/html/bug-hurd/2011-10/msg00035.html

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---

Same patch as last time. At least in the Hurd port, GLRO(dl_pagesize)
is one of the very things to get initialized, so this shouldn't cause
any initialization order issues. But, if it's really undesirable for
EXEC_PAGESIZE to be dropped, we could of course also define
EXEC_PAGESIZE to some large value (16K?) on aarch64-gnu, provided that
nothing actually tries to use it for anything.

PAGE_SIZE is 4k in the current AArch64 GNU Mach, for what it's worth,
but this is intended to eventually be build-time configurable.

 elf/dl-support.c | 6 +++++-
 elf/rtld.c       | 2 ++
 libio/libioP.h   | 2 +-
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/elf/dl-support.c b/elf/dl-support.c
index 451932dd..cb0bbd21 100644
--- a/elf/dl-support.c
+++ b/elf/dl-support.c
@@ -135,7 +135,11 @@ void *_dl_random;
 #include <dl-procruntime.c>
 #include <dl-procinfo.c>
 
-size_t _dl_pagesize = EXEC_PAGESIZE;
+size_t _dl_pagesize
+#ifdef EXEC_PAGESIZE
+  = EXEC_PAGESIZE
+#endif
+;
 
 size_t _dl_minsigstacksize = CONSTANT_MINSIGSTKSZ;
 
diff --git a/elf/rtld.c b/elf/rtld.c
index ac4bb236..18d73f19 100644
--- a/elf/rtld.c
+++ b/elf/rtld.c
@@ -358,7 +358,9 @@ struct rtld_global_ro _rtld_global_ro attribute_relro =
     ._dl_debug_fd = STDERR_FILENO,
     ._dl_lazy = 1,
     ._dl_fpu_control = _FPU_DEFAULT,
+#ifdef EXEC_PAGESIZE
     ._dl_pagesize = EXEC_PAGESIZE,
+#endif
     ._dl_inhibit_cache = 0,
     ._dl_profile_output = "/var/tmp",
 
diff --git a/libio/libioP.h b/libio/libioP.h
index 1af287b1..1a7f547e 100644
--- a/libio/libioP.h
+++ b/libio/libioP.h
@@ -852,7 +852,7 @@ extern off64_t _IO_seekpos_unlocked (FILE *, off64_t, int)
 #  define MAP_ANONYMOUS MAP_ANON
 # endif
 
-# if !defined(MAP_ANONYMOUS) || !defined(EXEC_PAGESIZE)
+# if !defined(MAP_ANONYMOUS)
 #  undef _G_HAVE_MMAP
 #  define _G_HAVE_MMAP 0
 # endif
-- 
2.44.0

[PATCH v2 04/20] hurd: Disable Prefer_MAP_32BIT_EXEC on non-x86_64 for now

[Sergey Bugaev]

While we could support it on any architecture, the tunable is currently
only defined on x86_64.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 sysdeps/mach/hurd/dl-sysdep.c | 2 +-
 sysdeps/mach/hurd/mmap.c      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/sysdeps/mach/hurd/dl-sysdep.c b/sysdeps/mach/hurd/dl-sysdep.c
index 43129a1e..6ba00e41 100644
--- a/sysdeps/mach/hurd/dl-sysdep.c
+++ b/sysdeps/mach/hurd/dl-sysdep.c
@@ -457,7 +457,7 @@ __mmap (void *addr, size_t len, int prot, int flags, int fd, off_t offset)
   if (prot & PROT_EXEC)
     vmprot |= VM_PROT_EXECUTE;
 
-#ifdef __LP64__
+#ifdef __x86_64__
   if ((addr == NULL) && (prot & PROT_EXEC)
       && HAS_ARCH_FEATURE (Prefer_MAP_32BIT_EXEC))
     flags |= MAP_32BIT;
diff --git a/sysdeps/mach/hurd/mmap.c b/sysdeps/mach/hurd/mmap.c
index 7b945610..30e369f0 100644
--- a/sysdeps/mach/hurd/mmap.c
+++ b/sysdeps/mach/hurd/mmap.c
@@ -60,7 +60,7 @@ __mmap (void *addr, size_t len, int prot, int flags, int fd, off_t offset)
   copy = ! (flags & MAP_SHARED);
   anywhere = ! (flags & MAP_FIXED);
 
-#ifdef __LP64__
+#ifdef __x86_64__
   if ((addr == NULL) && (prot & PROT_EXEC)
       && HAS_ARCH_FEATURE (Prefer_MAP_32BIT_EXEC))
     flags |= MAP_32BIT;
-- 
2.44.0

[PATCH v2 05/20] hurd: Use the RETURN_ADDRESS macro

[Sergey Bugaev]

This gives us PAC stripping on AArch64.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---

PAC is still not implemented on gnumach side, though.

 sysdeps/mach/hurd/init-first.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sysdeps/mach/hurd/init-first.c b/sysdeps/mach/hurd/init-first.c
index 22c35747..5777c44c 100644
--- a/sysdeps/mach/hurd/init-first.c
+++ b/sysdeps/mach/hurd/init-first.c
@@ -222,7 +222,7 @@ _hurd_stack_setup (void **argptr)
      this may not be a valid pointer in case we're supposed to receive the
      arguments from the exec server, so we can not dereference it yet.  */
 
-  void *caller = __builtin_extract_return_addr (__builtin_return_address (0));
+  void *caller = RETURN_ADDRESS (0);
   /* Init the essential things.  */
   first_init ();
 
-- 
2.44.0

[PATCH v2 06/20] htl: Respect GL(dl_stack_flags) when allocating stacks

[Sergey Bugaev]

Previously, HTL would always allocate non-executable stacks.  This has
never been noticed, since GNU Mach on x86 ignores VM_PROT_EXECUTE and
makes all pages implicitly executable.  Since GNU Mach on AArch64
supports non-executable pages, HTL forgetting to pass VM_PROT_EXECUTE
immediately breaks any code that (unfortunately, still) relies on
executable stacks.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 sysdeps/htl/Versions              | 4 ++++
 sysdeps/mach/htl/pt-stack-alloc.c | 9 +++++++--
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/sysdeps/htl/Versions b/sysdeps/htl/Versions
index 3a3b1e8b..7b5450d2 100644
--- a/sysdeps/htl/Versions
+++ b/sysdeps/htl/Versions
@@ -12,4 +12,8 @@ libc {
     pthread_spin_destroy; pthread_spin_init; pthread_spin_lock;
     pthread_spin_trylock; pthread_spin_unlock;
   }
+
+  GLIBC_PRIVATE {
+    __vm_map;
+  }
 }
diff --git a/sysdeps/mach/htl/pt-stack-alloc.c b/sysdeps/mach/htl/pt-stack-alloc.c
index 61974bd5..0597770b 100644
--- a/sysdeps/mach/htl/pt-stack-alloc.c
+++ b/sysdeps/mach/htl/pt-stack-alloc.c
@@ -31,9 +31,14 @@ int
 __pthread_stack_alloc (void **stackaddr, size_t stacksize)
 {
   error_t err;
+  vm_prot_t prot = VM_PROT_READ | VM_PROT_WRITE;
 
-  err = __vm_allocate (__mach_task_self (), (vm_offset_t *) stackaddr,
-		       stacksize, TRUE);
+  if (GL(dl_stack_flags) & PF_X)
+    prot |= VM_PROT_EXECUTE;
+
+  err = __vm_map (__mach_task_self (), (vm_offset_t *) stackaddr,
+		  stacksize, 0, TRUE, MEMORY_OBJECT_NULL, 0, FALSE,
+		  prot, VM_PROT_ALL, VM_INHERIT_COPY);
 
   if (err == KERN_NO_SPACE)
     err = EAGAIN;
-- 
2.44.0

[PATCH v2 07/20] aarch64: Move pointer_guard.h out of sysdeps/unix/sysv/linux

[Sergey Bugaev]

Nothing about this is Linux-specific.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 sysdeps/{unix/sysv/linux => }/aarch64/pointer_guard.h | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename sysdeps/{unix/sysv/linux => }/aarch64/pointer_guard.h (100%)

diff --git a/sysdeps/unix/sysv/linux/aarch64/pointer_guard.h b/sysdeps/aarch64/pointer_guard.h
similarity index 100%
rename from sysdeps/unix/sysv/linux/aarch64/pointer_guard.h
rename to sysdeps/aarch64/pointer_guard.h
-- 
2.44.0

[PATCH v2 08/20] aarch64: Add dl-procinfo

[Sergey Bugaev]

This is based on the Linux version, but doesn't define
GLRO(dl_aarch64_cap_flags) and implement _dl_hwcap_string (which seems
unused anyway) based on Linux HWCAP bit values.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 sysdeps/aarch64/dl-procinfo.c | 59 +++++++++++++++++++++++++++++++++++
 sysdeps/aarch64/dl-procinfo.h | 38 ++++++++++++++++++++++
 2 files changed, 97 insertions(+)
 create mode 100644 sysdeps/aarch64/dl-procinfo.c
 create mode 100644 sysdeps/aarch64/dl-procinfo.h

diff --git a/sysdeps/aarch64/dl-procinfo.c b/sysdeps/aarch64/dl-procinfo.c
new file mode 100644
index 00000000..5a51edbc
--- /dev/null
+++ b/sysdeps/aarch64/dl-procinfo.c
@@ -0,0 +1,59 @@
+/* Data for AArch64 version of processor capability information.
+   Copyright (C) 2017-2024 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/>.  */
+
+/* If anything should be added here check whether the size of each string
+   is still ok with the given array size.
+
+   All the #ifdefs in the definitions are quite irritating but
+   necessary if we want to avoid duplicating the information.  There
+   are three different modes:
+
+   - PROCINFO_DECL is defined.  This means we are only interested in
+     declarations.
+
+   - PROCINFO_DECL is not defined:
+
+     + if SHARED is defined the file is included in an array
+       initializer.  The .element = { ... } syntax is needed.
+
+     + if SHARED is not defined a normal array initialization is
+       needed.
+  */
+
+#ifndef PROCINFO_CLASS
+# define PROCINFO_CLASS
+#endif
+
+#if !IS_IN (ldconfig)
+# if !defined PROCINFO_DECL && defined SHARED
+  ._dl_aarch64_cpu_features
+# else
+PROCINFO_CLASS struct cpu_features _dl_aarch64_cpu_features
+# endif
+# ifndef PROCINFO_DECL
+= { }
+# endif
+# if !defined SHARED || defined PROCINFO_DECL
+;
+# else
+,
+# endif
+#endif
+
+#undef PROCINFO_DECL
+#undef PROCINFO_CLASS
diff --git a/sysdeps/aarch64/dl-procinfo.h b/sysdeps/aarch64/dl-procinfo.h
new file mode 100644
index 00000000..176de5cd
--- /dev/null
+++ b/sysdeps/aarch64/dl-procinfo.h
@@ -0,0 +1,38 @@
+/* Processor capability information handling macros - aarch64 version.
+   Copyright (C) 2017-2024 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/>.  */
+
+#ifndef _DL_PROCINFO_H
+#define _DL_PROCINFO_H	1
+
+#include <sys/auxv.h>
+#include <unistd.h>
+#include <ldsodefs.h>
+#include <sysdep.h>
+
+/* We cannot provide a general printing function.  */
+#define _dl_procinfo(type, word) -1
+
+/* No additional library search paths.  */
+#define HWCAP_IMPORTANT HWCAP_ATOMICS
+
+/* There're no platforms to filter out.  */
+#define _DL_HWCAP_PLATFORM 0
+
+#define _dl_string_platform(str) (-1)
+
+#endif /* dl-procinfo.h */
-- 
2.44.0

[PATCH v2 09/20] aarch64: Move saving user entry into _dl_start_user

[Sergey Bugaev]

In the Hurd ports, _dl_start () does not return the normal way; instead,
_dl_sysdep_start () jumps to _dl_start_user directly using the RETURN_TO
macro.  Unlike in the i386 and x86_64 ports, the instruction that was
saving the returned user entry into a different register (to avoid it
getting clobbered by the _dl_init () call) was not marked as a part of
_dl_start_user, causing it to be skipped when jumping to _dl_start_user
using RETURN_TO, and control subsequently getting transferred to a
random address left in x21.

This should not make any difference for Linux ports, other than the
_dl_start_user label pointing to an earlier instruction.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 sysdeps/aarch64/dl-start.S | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sysdeps/aarch64/dl-start.S b/sysdeps/aarch64/dl-start.S
index d645484e..e35431ca 100644
--- a/sysdeps/aarch64/dl-start.S
+++ b/sysdeps/aarch64/dl-start.S
@@ -29,10 +29,10 @@ ENTRY (_start)
 	PTR_ARG (0)
 	bl	_dl_start
 	/* Returns user entry point in x0.  */
-	mov	PTR_REG (21), PTR_REG (0)
 .globl _dl_start_user
 .type _dl_start_user, %function
 _dl_start_user:
+	mov	PTR_REG (21), PTR_REG (0)
 	/* Get argc.  */
 	ldr	PTR_REG (1), [sp]
 	/* Get argv.  */
-- 
2.44.0

[PATCH v2 10/20] aarch64: Allow building without kernel support for BTI

[Sergey Bugaev]

If PROT_BTI is not defined, turn _dl_bti_protect () into a no-op.

We intend to support BTI & PROT_BTI on the Hurd eventually, but we're
not there yet.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 sysdeps/aarch64/dl-bti.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/sysdeps/aarch64/dl-bti.c b/sysdeps/aarch64/dl-bti.c
index fd0d308a..4cf85630 100644
--- a/sysdeps/aarch64/dl-bti.c
+++ b/sysdeps/aarch64/dl-bti.c
@@ -28,6 +28,7 @@
 
 /* Enable BTI protection for MAP.  */
 
+#ifdef PROT_BTI
 void
 _dl_bti_protect (struct link_map *map, int fd)
 {
@@ -59,6 +60,15 @@ _dl_bti_protect (struct link_map *map, int fd)
       }
 }
 
+#else /* PROT_BTI */
+void
+_dl_bti_protect (struct link_map *map, int fd)
+{
+  (void) map;
+  (void) fd;
+}
+#endif
+
 
 static void
 bti_failed (struct link_map *l, const char *program)
-- 
2.44.0

[PATCH v2 11/20] mach: Add a basic AArch64 port

[Sergey Bugaev]

This doesn't add any of the Hurd- or HTL-specific bits yet.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 mach/Makefile                          |   1 +
 sysdeps/mach/aarch64/bits/mach/param.h |  24 ++++++
 sysdeps/mach/aarch64/cpu-features.c    | 109 +++++++++++++++++++++++++
 sysdeps/mach/aarch64/sys/ucontext.h    |  73 +++++++++++++++++
 sysdeps/mach/aarch64/sysdep.h          |  52 ++++++++++++
 sysdeps/mach/aarch64/thread_state.h    |  49 +++++++++++
 sysdeps/mach/configure                 |   1 +
 sysdeps/mach/configure.ac              |   1 +
 8 files changed, 310 insertions(+)
 create mode 100644 sysdeps/mach/aarch64/bits/mach/param.h
 create mode 100644 sysdeps/mach/aarch64/cpu-features.c
 create mode 100644 sysdeps/mach/aarch64/sys/ucontext.h
 create mode 100644 sysdeps/mach/aarch64/sysdep.h
 create mode 100644 sysdeps/mach/aarch64/thread_state.h

diff --git a/mach/Makefile b/mach/Makefile
index 0ea3b3c1..92394951 100644
--- a/mach/Makefile
+++ b/mach/Makefile
@@ -56,6 +56,7 @@ generated =
 
 # Avoid ssp before TLS is initialized.
 CFLAGS-mach_init.o = $(no-stack-protector)
+CFLAGS-RPC_aarch64_get_hwcaps.o = $(no-stack-protector)
 CFLAGS-RPC_vm_statistics.o = $(no-stack-protector)
 CFLAGS-RPC_vm_map.o = $(no-stack-protector)
 CFLAGS-RPC_vm_protect.o = $(no-stack-protector)
diff --git a/sysdeps/mach/aarch64/bits/mach/param.h b/sysdeps/mach/aarch64/bits/mach/param.h
new file mode 100644
index 00000000..4f7b76ed
--- /dev/null
+++ b/sysdeps/mach/aarch64/bits/mach/param.h
@@ -0,0 +1,24 @@
+/* Old-style Unix parameters and limits.  aarch64 Mach version.
+   Copyright (C) 1993-2024 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/>.  */
+
+#ifndef _SYS_PARAM_H
+# error "Never use <bits/mach/param.h> directly; include <sys/param.h> instead."
+#endif
+
+/* There is no EXEC_PAGESIZE.  Use vm_page_size or getpagesize ()
+   or sysconf (_SC_PAGESIZE) instead.  */
diff --git a/sysdeps/mach/aarch64/cpu-features.c b/sysdeps/mach/aarch64/cpu-features.c
new file mode 100644
index 00000000..1d1f5201
--- /dev/null
+++ b/sysdeps/mach/aarch64/cpu-features.c
@@ -0,0 +1,109 @@
+/* Initialize CPU feature data.  Mach AArch64 version.
+   This file is part of the GNU C Library.
+   Copyright (C) 2017-2024 Free Software Foundation, Inc.
+
+   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 <array_length.h>
+#include <cpu-features.h>
+#include <elf/dl-hwcaps.h>
+#include <dl-tunables-parse.h>
+#include <mach/aarch64/mach_aarch64.h>
+
+#define DCZID_DZP_MASK (1 << 4)
+#define DCZID_BS_MASK (0xf)
+
+/* The maximal set of permitted tags that the MTE random tag generation
+   instruction may use.  We exclude tag 0 because a) we want to reserve
+   that for the libc heap structures and b) because it makes it easier
+   to see when pointer have been correctly tagged.  */
+#define MTE_ALLOWED_TAGS (0xfffe << PR_MTE_TAG_SHIFT)
+
+struct cpu_list
+{
+  const char *name;
+  size_t len;
+  uint64_t midr;
+};
+
+static const struct cpu_list cpu_list[] =
+{
+#define CPU_LIST_ENTRY(__str, __num) { __str, sizeof (__str) - 1, __num }
+  CPU_LIST_ENTRY ("thunderxt88",    0x430F0A10),
+  CPU_LIST_ENTRY ("thunderx2t99",   0x431F0AF0),
+  CPU_LIST_ENTRY ("thunderx2t99p1", 0x420F5160),
+  CPU_LIST_ENTRY ("ares",           0x411FD0C0),
+  CPU_LIST_ENTRY ("emag",           0x503F0001),
+  CPU_LIST_ENTRY ("kunpeng920",     0x481FD010),
+  CPU_LIST_ENTRY ("a64fx",          0x460F0010),
+  CPU_LIST_ENTRY ("generic",        0x0),
+};
+
+static uint64_t
+get_midr_from_mcpu (const struct tunable_str_t *mcpu)
+{
+  for (int i = 0; i < array_length (cpu_list); i++)
+    if (tunable_strcmp (mcpu, cpu_list[i].name, cpu_list[i].len))
+      return cpu_list[i].midr;
+
+  return UINT64_MAX;
+}
+
+static inline void
+init_cpu_features (struct cpu_features *cpu_features)
+{
+  error_t err;
+  uint32_t hwcaps[HWCAPS_COUNT];
+  mach_msg_type_number_t hwcaps_size = HWCAPS_COUNT;
+  uint64_t midr, revidr;
+
+  err = __aarch64_get_hwcaps (__mach_host_self (), hwcaps,
+			      &hwcaps_size, &midr, &revidr);
+  assert_perror (err);
+
+  if (hwcaps_size >= 1)
+    GLRO (dl_hwcap) = hwcaps[0];
+  if (hwcaps_size >= 2)
+    GLRO (dl_hwcap2) = hwcaps[1];
+
+  cpu_features->midr_el1 = midr;
+
+  /* Get the tunable override.  */
+  const struct tunable_str_t *mcpu = TUNABLE_GET (glibc, cpu, name,
+						  struct tunable_str_t *,
+						  NULL);
+  if (mcpu != NULL)
+    {
+      midr = get_midr_from_mcpu (mcpu);
+      if (midr != UINT64_MAX)
+        cpu_features->midr_el1 = midr;
+    }
+
+  /* Check if ZVA is enabled.  */
+  unsigned dczid;
+  asm volatile ("mrs %0, dczid_el0" : "=r"(dczid));
+
+  if ((dczid & DCZID_DZP_MASK) == 0)
+    cpu_features->zva_size = 4 << (dczid & DCZID_BS_MASK);
+
+  /* Check if BTI is supported.  */
+  cpu_features->bti = GLRO (dl_hwcap2) & HWCAP2_BTI;
+
+  /* Check if SVE is supported.  */
+  cpu_features->sve = GLRO (dl_hwcap) & HWCAP_SVE;
+
+  /* Check if MOPS is supported.  */
+  cpu_features->mops = GLRO (dl_hwcap2) & HWCAP2_MOPS;
+}
diff --git a/sysdeps/mach/aarch64/sys/ucontext.h b/sysdeps/mach/aarch64/sys/ucontext.h
new file mode 100644
index 00000000..69b95476
--- /dev/null
+++ b/sysdeps/mach/aarch64/sys/ucontext.h
@@ -0,0 +1,73 @@
+/* Copyright (C) 1998-2024 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/>.  */
+
+/* System V/AArch64 ABI compliant context switching support.  */
+
+#ifndef _SYS_UCONTEXT_H
+#define _SYS_UCONTEXT_H	1
+
+#include <features.h>
+
+#include <bits/types/sigset_t.h>
+#include <bits/types/stack_t.h>
+
+#ifdef __USE_MISC
+# define __ctx(fld) fld
+#else
+# define __ctx(fld) __ ## fld
+#endif
+
+/* Type for general register.  */
+__extension__ typedef long long int greg_t;
+
+/* gregset_t is laid out to match mach/aarch64/thread_status.h:struct aarch64_thread_state */
+typedef struct
+{
+  greg_t __ctx(x)[31];
+  greg_t __ctx(sp);
+  greg_t __ctx(pc);
+  greg_t __ctx(tpidr_el0);
+  unsigned long __ctx(cpsr);
+} gregset_t;
+
+/* fpregset_t is laid out to match mach/aarch64/thread_status.h:struct aarch64_float_state */
+typedef struct
+{
+  __int128_t __ctx(v)[32];
+  unsigned long __ctx(fpsr);
+  unsigned long __ctx(fpcr);
+} fpregset_t;
+
+typedef struct
+{
+  gregset_t __ctx(gregs);
+  fpregset_t __ctx(fpregs);
+} mcontext_t;
+
+typedef struct ucontext_t
+{
+  unsigned long __ctx(uc_flags);
+  struct ucontext_t *uc_link;
+  stack_t uc_stack;
+  sigset_t uc_sigmask;
+  mcontext_t uc_mcontext;
+} ucontext_t;
+
+#undef __ctx
+
+#endif /* sys/ucontext.h */
diff --git a/sysdeps/mach/aarch64/sysdep.h b/sysdeps/mach/aarch64/sysdep.h
new file mode 100644
index 00000000..ad5bf3b5
--- /dev/null
+++ b/sysdeps/mach/aarch64/sysdep.h
@@ -0,0 +1,52 @@
+/* Copyright (C) 1991-2024 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/>.  */
+
+#ifndef _MACH_AARCH64_SYSDEP_H
+#define _MACH_AARCH64_SYSDEP_H 1
+
+/* Defines RTLD_PRIVATE_ERRNO and USE_DL_SYSINFO.  */
+#include <dl-sysdep.h>
+#include <tls.h>
+/* Get the hwcap definitions.  */
+#include <mach/aarch64/mach_aarch64_types.h>
+
+#define LOSE asm volatile ("udf #0xdead")
+
+#define STACK_GROWTH_DOWN
+
+/* Get the machine-independent Mach definitions.  */
+#include <sysdeps/mach/sysdep.h>
+
+#undef ENTRY
+#undef ALIGN
+
+#define RETURN_TO(sp, pc, retval)					      \
+do									      \
+  {									      \
+    register long __rv asm ("x0") = (retval);				      \
+    asm volatile ("mov sp, %0\n\t"					      \
+		  "ret %1"						      \
+		  :: "r" (sp), "r" (pc), "r" (__rv));			      \
+    __builtin_unreachable ();						      \
+  }									      \
+while (0)
+
+#include <sysdeps/aarch64/sysdep.h>
+#include <sysdeps/unix/sysdep.h>
+
+#endif /* mach/aarch64/sysdep.h */
diff --git a/sysdeps/mach/aarch64/thread_state.h b/sysdeps/mach/aarch64/thread_state.h
new file mode 100644
index 00000000..f15859ee
--- /dev/null
+++ b/sysdeps/mach/aarch64/thread_state.h
@@ -0,0 +1,49 @@
+/* Mach thread state definitions for machine-independent code.  AArch64 version.
+   Copyright (C) 1994-2024 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/>.  */
+
+#ifndef _MACH_AARCH64_THREAD_STATE_H
+#define _MACH_AARCH64_THREAD_STATE_H 1
+
+#include <mach/machine/thread_status.h>
+#include <libc-pointer-arith.h>
+
+#define MACHINE_NEW_THREAD_STATE_FLAVOR	AARCH64_THREAD_STATE
+#define MACHINE_THREAD_STATE_FLAVOR	AARCH64_THREAD_STATE
+#define MACHINE_THREAD_STATE_COUNT	AARCH64_THREAD_STATE_COUNT
+
+#define machine_thread_state aarch64_thread_state
+
+#define PC pc
+#define SP sp
+#define SYSRETURN x[0]
+
+#define MACHINE_THREAD_STATE_SETUP_CALL(ts, stack, size, func)		      \
+  ((ts)->sp = PTR_ALIGN_DOWN ((uintptr_t) (stack) + (size), 16),	      \
+   (ts)->pc = (uintptr_t) func,						      \
+   (ts)->cpsr = 0x0)	/* notably, reset BTYPE */
+
+struct machine_thread_all_state
+  {
+    struct aarch64_thread_state basic;
+    struct aarch64_float_state fpu;
+    int set;
+  };
+
+#include <sysdeps/mach/thread_state.h>
+
+#endif /* mach/aarch64/thread_state.h */
diff --git a/sysdeps/mach/configure b/sysdeps/mach/configure
index f15160d0..18f98967 100644
--- a/sysdeps/mach/configure
+++ b/sysdeps/mach/configure
@@ -268,6 +268,7 @@ for ifc in mach mach4 gnumach \
 	   clock clock_priv host_priv host_security ledger lock_set \
 	   processor processor_set task task_notify thread_act vm_map \
 	   memory_object memory_object_default i386/mach_i386 x86_64/mach_i386 \
+	   aarch64/mach_aarch64 \
 	   ; do
   as_ac_Header=`printf "%s\n" "ac_cv_header_mach/${ifc}.defs" | $as_tr_sh`
 ac_fn_c_check_header_preproc "$LINENO" "mach/${ifc}.defs" "$as_ac_Header"
diff --git a/sysdeps/mach/configure.ac b/sysdeps/mach/configure.ac
index 730fb25d..03e45df2 100644
--- a/sysdeps/mach/configure.ac
+++ b/sysdeps/mach/configure.ac
@@ -64,6 +64,7 @@ for ifc in mach mach4 gnumach \
 	   clock clock_priv host_priv host_security ledger lock_set \
 	   processor processor_set task task_notify thread_act vm_map \
 	   memory_object memory_object_default i386/mach_i386 x86_64/mach_i386 \
+	   aarch64/mach_aarch64 \
 	   ; do
   AC_CHECK_HEADER(mach/${ifc}.defs, [dnl
   mach_interface_list="$mach_interface_list $ifc"],, -)
-- 
2.44.0

[PATCH v2 12/20] mach: Declare the new thread_set_self_state () trap

[Sergey Bugaev]

This is a new Mach trap for setting the state of the current thread, as
if with thread_set_state () RPC.  The trap has been added to GNU Mach as
a part of the AArch64 port, to make it possible to implement sigreturn
in glibc; however, the trap itself is fully arch-independent.

There does not seem to be an easy way to feature-test, in a header, for
existence of traps in the Mach version being built against.  Instead,
just declare the trap prototype unconditionally, and don't add an
exported version for now.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 sysdeps/mach/include/mach/mach_traps.h | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/sysdeps/mach/include/mach/mach_traps.h b/sysdeps/mach/include/mach/mach_traps.h
index c4334952..a942212c 100644
--- a/sysdeps/mach/include/mach/mach_traps.h
+++ b/sysdeps/mach/include/mach/mach_traps.h
@@ -19,5 +19,12 @@ kern_return_t __thread_switch (mach_port_t new_thread,
 libc_hidden_proto (__thread_switch)
 kern_return_t __evc_wait (unsigned int event);
 libc_hidden_proto (__evc_wait)
+
+/* Set current thread's state, as if with thread_set_state() RPC.
+   This syscall is only really available in recent enough GNU Mach.  */
+extern kern_return_t __thread_set_self_state (int flavor,
+					      natural_t *new_state,
+					      natural_t new_state_count);
+libc_hidden_proto (__thread_set_self_state)
 #endif
 #endif
-- 
2.44.0

[PATCH v2 13/20] hurd: Add a basic AArch64 port

[Sergey Bugaev]

The following commits will add TLS, HTL, and the signal bits.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 sysdeps/mach/hurd/aarch64/Implies        |  3 ++
 sysdeps/mach/hurd/aarch64/longjmp-ts.c   | 49 ++++++++++++++++++++++
 sysdeps/mach/hurd/aarch64/shlib-versions |  2 +
 sysdeps/mach/hurd/aarch64/static-start.S | 52 ++++++++++++++++++++++++
 sysdeps/mach/hurd/aarch64/vm_param.h     | 24 +++++++++++
 5 files changed, 130 insertions(+)
 create mode 100644 sysdeps/mach/hurd/aarch64/Implies
 create mode 100644 sysdeps/mach/hurd/aarch64/longjmp-ts.c
 create mode 100644 sysdeps/mach/hurd/aarch64/shlib-versions
 create mode 100644 sysdeps/mach/hurd/aarch64/static-start.S
 create mode 100644 sysdeps/mach/hurd/aarch64/vm_param.h

diff --git a/sysdeps/mach/hurd/aarch64/Implies b/sysdeps/mach/hurd/aarch64/Implies
new file mode 100644
index 00000000..02af165f
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/Implies
@@ -0,0 +1,3 @@
+mach/hurd/htl
+aarch64/htl
+mach/hurd/aarch64/htl
diff --git a/sysdeps/mach/hurd/aarch64/longjmp-ts.c b/sysdeps/mach/hurd/aarch64/longjmp-ts.c
new file mode 100644
index 00000000..2fcb7493
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/longjmp-ts.c
@@ -0,0 +1,49 @@
+/* Perform a `longjmp' on a Mach thread_state.  AArch64 version.
+   Copyright (C) 1991-2024 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 <setjmp.h>
+#include <jmpbuf-offsets.h>
+#include <mach/thread_status.h>
+
+
+/* Set up STATE to do the equivalent of `longjmp (ENV, VAL);'.  */
+
+void
+_hurd_longjmp_thread_state (void *state, jmp_buf env, int val)
+{
+  struct aarch64_thread_state *ts = state;
+
+  ts->x[19] = env[0].__jmpbuf[JB_X19];
+  ts->x[20] = env[0].__jmpbuf[JB_X20];
+  ts->x[21] = env[0].__jmpbuf[JB_X21];
+  ts->x[22] = env[0].__jmpbuf[JB_X22];
+  ts->x[23] = env[0].__jmpbuf[JB_X23];
+  ts->x[24] = env[0].__jmpbuf[JB_X24];
+  ts->x[25] = env[0].__jmpbuf[JB_X25];
+  ts->x[26] = env[0].__jmpbuf[JB_X26];
+  ts->x[27] = env[0].__jmpbuf[JB_X27];
+  ts->x[28] = env[0].__jmpbuf[JB_X28];
+  ts->x[29] = env[0].__jmpbuf[JB_X29];
+
+  /* XXX: We're ignoring all the d[] (SIMD) registers.
+     Is that fine?  */
+
+  ts->pc = PTR_DEMANGLE (env[0].__jmpbuf[JB_LR]);
+  ts->sp = _jmpbuf_sp (env[0].__jmpbuf);
+  ts->x[0] = val ?: 1;
+}
diff --git a/sysdeps/mach/hurd/aarch64/shlib-versions b/sysdeps/mach/hurd/aarch64/shlib-versions
new file mode 100644
index 00000000..b9e7c2cb
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/shlib-versions
@@ -0,0 +1,2 @@
+DEFAULT			GLIBC_2.40
+ld=ld-aarch64.so.1
diff --git a/sysdeps/mach/hurd/aarch64/static-start.S b/sysdeps/mach/hurd/aarch64/static-start.S
new file mode 100644
index 00000000..e09865c4
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/static-start.S
@@ -0,0 +1,52 @@
+/* Startup code for statically linked Hurd/AArch64 binaries.
+   Copyright (C) 1998-2024 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 <sysdep.h>
+
+/* This is the actual entry point for statically linked aarch64-gnu executables,
+   the very first code to run in a process.  */
+
+	.text
+ENTRY(_start)
+	/* Set up the initial stack frame.  */
+	cfi_undefined (x30)
+	mov	x29, #0
+	mov	x30, #0
+
+	/* Pre-fill GOT entries for select ifunc routines that may get
+	   called during _hurd_stack_setup () with baseline implementations.  */
+	adrp	x1, __memcpy_generic
+	add	x1, x1, #:lo12:__memcpy_generic
+	adrp	x0, :got:memcpy
+	str	x1, [x0, :got_lo12:memcpy]
+
+	adrp	x1, __strlen_generic
+	add	x1, x1, #:lo12:__strlen_generic
+	adrp	x0, :got:strlen
+	str	x1, [x0, :got_lo12:strlen]
+
+	mov	x0, sp
+	bl	_hurd_stack_setup
+
+	/* Jump to the regular entry point.  */
+	mov	x0, #0
+	b	_start1
+END(_start)
+
+#define _start _start1
+#include <sysdeps/aarch64/start.S>
diff --git a/sysdeps/mach/hurd/aarch64/vm_param.h b/sysdeps/mach/hurd/aarch64/vm_param.h
new file mode 100644
index 00000000..304a2f2b
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/vm_param.h
@@ -0,0 +1,24 @@
+/* Copyright (C) 2020-2024 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/>.  */
+
+#ifndef _AARCH64_VM_PARAM_H
+#define _AARCH64_VM_PARAM_H
+
+/* Arbitrary start of the brk. This is after usual binary and library mappings.  */
+#define BRK_START	0x200000000000
+
+#endif /* aarch64/vm_param.h */
-- 
2.44.0

[PATCH v2 14/20] hurd: Implement TLS on AArch64

[Sergey Bugaev]

This is using TLS_DTV_AT_TP, aka "Variant I" layout. tpidr_el0, which is
both readable and writable from userspace, is used as the thread pointer.

We store our Hurd-specific data (sigstate and reply port) *before* the
TCB head, in a tcbprehead_t structure. This tcbprehead_t structure is
also what THREAD_SELF, THREAD_GETMEM, and THREAD_SETMEM macros access.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 .../mach/hurd/aarch64/dl-tls-initialized.c    |  19 ++
 sysdeps/mach/hurd/aarch64/tls.h               | 206 ++++++++++++++++++
 2 files changed, 225 insertions(+)
 create mode 100644 sysdeps/mach/hurd/aarch64/dl-tls-initialized.c
 create mode 100644 sysdeps/mach/hurd/aarch64/tls.h

diff --git a/sysdeps/mach/hurd/aarch64/dl-tls-initialized.c b/sysdeps/mach/hurd/aarch64/dl-tls-initialized.c
new file mode 100644
index 00000000..9beafec3
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/dl-tls-initialized.c
@@ -0,0 +1,19 @@
+/* Determine whether TLS is initialized, for AArch64/Hurd.
+   Copyright (C) 1995-2024 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/>.  */
+
+/* Nothing here, it's all handled in tls.h */
diff --git a/sysdeps/mach/hurd/aarch64/tls.h b/sysdeps/mach/hurd/aarch64/tls.h
new file mode 100644
index 00000000..712134e1
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/tls.h
@@ -0,0 +1,206 @@
+/* Copyright (C) 2005-2024 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/>.  */
+
+#ifndef _AARCH64_TLS_H
+#define _AARCH64_TLS_H	1
+
+/* Some things really need not be machine-dependent.  */
+#include <sysdeps/mach/hurd/tls.h>
+
+#include <dl-sysdep.h>
+
+#ifndef __ASSEMBLER__
+# include <assert.h>
+# include <stdbool.h>
+# include <stddef.h>
+# include <stdint.h>
+# include <dl-dtv.h>
+# include <errno.h>
+# include <thread_state.h>
+#endif /* __ASSEMBLER__ */
+
+#ifndef __ASSEMBLER__
+
+/* Get system call information.  */
+# include <sysdep.h>
+
+/* The TP points to the start of the thread blocks.  */
+# define TLS_DTV_AT_TP	1
+# define TLS_TCB_AT_TP	0
+
+typedef struct
+{
+  /* Used by the exception handling implementation in the dynamic loader.  */
+  struct rtld_catch *rtld_catch;
+
+  struct hurd_sigstate *_hurd_sigstate;
+  mach_port_t reply_port;      /* This thread's reply port.  */
+
+  int gscope_flag;
+} tcbprehead_t;
+
+typedef struct
+{
+  dtv_t *dtv;
+  void *private;
+} tcbhead_t;
+
+/* This is the size of the initial TCB.  */
+# define TLS_INIT_TCB_SIZE	sizeof (tcbhead_t)
+
+/* This is the size we need before TCB.  */
+# define TLS_PRE_TCB_SIZE	sizeof (tcbprehead_t)
+
+# define TCB_ALIGNMENT		64
+
+/* Install new dtv for current thread.  */
+# define INSTALL_NEW_DTV(dtv) \
+  (THREAD_DTV() = (dtv))
+
+/* Return the address of the dtv for the current thread.  */
+# define THREAD_DTV() \
+  (((tcbhead_t *) __builtin_thread_pointer ())->dtv)
+
+/* Return the thread descriptor for the current thread.  */
+# define THREAD_SELF \
+ ((tcbprehead_t *)__builtin_thread_pointer () - 1)
+
+/* Read member of the thread descriptor directly.  */
+# define THREAD_GETMEM(descr, member) \
+  ((descr)->member)
+
+/* Write member of the thread descriptor directly.  */
+# define THREAD_SETMEM(descr, member, value) \
+  ((descr)->member = (value))
+
+/* Return the TCB address of a thread given its state.
+   Note: this is expensive.  */
+static inline tcbprehead_t * __attribute__ ((unused))
+THREAD_TCB (thread_t thread,
+            struct machine_thread_all_state *all_state)
+{
+  int ok;
+  const struct aarch64_thread_state *state;
+  tcbhead_t *tcb;
+
+  ok = machine_get_basic_state (thread, all_state);
+  assert (ok);
+  state = &((struct machine_thread_all_state *) all_state)->basic;
+  tcb = (tcbhead_t *) state->tpidr_el0;
+  return (tcbprehead_t *) tcb - 1;
+}
+
+/* From hurd.h, reproduced here to avoid a circular include.  */
+extern thread_t __hurd_thread_self (void);
+libc_hidden_proto (__hurd_thread_self);
+
+/* Set up TLS in the new thread of a fork child, copying from the original.  */
+static inline kern_return_t __attribute__ ((unused))
+_hurd_tls_fork (thread_t child, thread_t orig,
+                struct aarch64_thread_state *state)
+{
+  error_t err;
+  struct aarch64_thread_state orig_state;
+  mach_msg_type_number_t state_count = AARCH64_THREAD_STATE_COUNT;
+
+  if (orig != __hurd_thread_self ())
+    {
+      err = __thread_get_state (orig, AARCH64_THREAD_STATE,
+				(thread_state_t) &orig_state,
+				&state_count);
+      if (err)
+        return err;
+      assert (state_count == AARCH64_THREAD_STATE_COUNT);
+      state->tpidr_el0 = orig_state.tpidr_el0;
+    }
+  else
+    state->tpidr_el0 = (uintptr_t) __builtin_thread_pointer ();
+  return 0;
+}
+
+static inline kern_return_t __attribute__ ((unused))
+_hurd_tls_new (thread_t child, tcbhead_t *tcb)
+{
+  error_t err;
+  struct aarch64_thread_state state;
+  mach_msg_type_number_t state_count = AARCH64_THREAD_STATE_COUNT;
+
+  err = __thread_get_state (child, AARCH64_THREAD_STATE,
+			    (thread_state_t) &state,
+			    &state_count);
+  if (err)
+    return err;
+  assert (state_count == AARCH64_THREAD_STATE_COUNT);
+
+  state.tpidr_el0 = (uintptr_t) tcb;
+
+  return __thread_set_state (child, AARCH64_THREAD_STATE,
+			     (thread_state_t) &state,
+			     state_count);
+}
+
+# if !defined (SHARED) || IS_IN (rtld)
+#  define __LIBC_NO_TLS() __builtin_expect (!__builtin_thread_pointer (), 0)
+
+static inline bool __attribute__ ((unused))
+_hurd_tls_init (tcbhead_t *tcb, bool full)
+{
+  extern mach_port_t __hurd_reply_port0;
+
+  if (full)
+    /* Take over the reply port we've been using.  */
+    (((tcbprehead_t *) tcb) - 1)->reply_port = __hurd_reply_port0;
+
+  __asm __volatile ("msr tpidr_el0, %0" : : "r" (tcb));
+  if (full)
+    /* This port is now owned by the TCB.  */
+    __hurd_reply_port0 = MACH_PORT_NULL;
+  return true;
+}
+
+#  define TLS_INIT_TP(descr) _hurd_tls_init ((tcbhead_t *) (descr), 1)
+# else /* defined (SHARED) && !IS_IN (rtld) */
+#  define __LIBC_NO_TLS() 0
+# endif
+
+/* Global scope switch support.  */
+# define THREAD_GSCOPE_FLAG_UNUSED 0
+# define THREAD_GSCOPE_FLAG_USED   1
+# define THREAD_GSCOPE_FLAG_WAIT   2
+
+# define THREAD_GSCOPE_SET_FLAG() \
+  do									     \
+    {									     \
+      THREAD_SELF->gscope_flag = THREAD_GSCOPE_FLAG_USED;		     \
+      atomic_write_barrier ();						     \
+    }									     \
+  while (0)
+
+# define THREAD_GSCOPE_RESET_FLAG() \
+  do									     \
+    { int __flag							     \
+	= atomic_exchange_release (&THREAD_SELF->gscope_flag,		     \
+				   THREAD_GSCOPE_FLAG_UNUSED);		     \
+      if (__flag == THREAD_GSCOPE_FLAG_WAIT)				     \
+	lll_wake (THREAD_SELF->gscope_flag, LLL_PRIVATE);		     \
+    }									     \
+  while (0)
+
+# endif /* __ASSEMBLER__ */
+
+#endif	/* tls.h */
-- 
2.44.0

[PATCH v2 15/20] hurd: Implement longjmp for AArch64

[Sergey Bugaev]

This is based on the generic AArch64 version, but it additionally
respects and updates the Hurd sigstate.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---

Same patch as last time.

Something somewhere here should probably be hooked up to the
hurd_userlink mechanism; I haven't looked into that.

 sysdeps/aarch64/htl/tcb-offsets.sym          |   5 +
 sysdeps/mach/hurd/aarch64/Makefile           |  24 +++
 sysdeps/mach/hurd/aarch64/____longjmp_chk.S  | 173 +++++++++++++++++++
 sysdeps/mach/hurd/aarch64/__longjmp.S        | 150 ++++++++++++++++
 sysdeps/mach/hurd/aarch64/signal-defines.sym |  10 ++
 5 files changed, 362 insertions(+)
 create mode 100644 sysdeps/aarch64/htl/tcb-offsets.sym
 create mode 100644 sysdeps/mach/hurd/aarch64/Makefile
 create mode 100644 sysdeps/mach/hurd/aarch64/____longjmp_chk.S
 create mode 100644 sysdeps/mach/hurd/aarch64/__longjmp.S
 create mode 100644 sysdeps/mach/hurd/aarch64/signal-defines.sym

diff --git a/sysdeps/aarch64/htl/tcb-offsets.sym b/sysdeps/aarch64/htl/tcb-offsets.sym
new file mode 100644
index 00000000..56140780
--- /dev/null
+++ b/sysdeps/aarch64/htl/tcb-offsets.sym
@@ -0,0 +1,5 @@
+#include <sysdep.h>
+#include <tls.h>
+#include <kernel-features.h>
+
+SIGSTATE_OFFSET         offsetof (tcbprehead_t, _hurd_sigstate) - sizeof (tcbprehead_t)
diff --git a/sysdeps/mach/hurd/aarch64/Makefile b/sysdeps/mach/hurd/aarch64/Makefile
new file mode 100644
index 00000000..9210d436
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/Makefile
@@ -0,0 +1,24 @@
+# Copyright (C) 2020-2024 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/>.
+
+ifeq ($(subdir),debug)
+gen-as-const-headers += signal-defines.sym
+endif
+
+ifeq ($(subdir),setjmp)
+gen-as-const-headers += signal-defines.sym
+endif
diff --git a/sysdeps/mach/hurd/aarch64/____longjmp_chk.S b/sysdeps/mach/hurd/aarch64/____longjmp_chk.S
new file mode 100644
index 00000000..90f062df
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/____longjmp_chk.S
@@ -0,0 +1,173 @@
+/* Copyright (C) 1997-2024 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 <asm-syntax.h>
+#include <jmpbuf-offsets.h>
+#include <pointer_guard.h>
+#include <tcb-offsets.h>
+#include <signal-defines.h>
+#include <stap-probe.h>
+#include <sysdep.h>
+
+#define SS_ONSTACK	1
+#define SS_ONSTACK_BIT	0
+
+	.section .rodata.str1.1,"aMS",%progbits,1
+	.type   longjmp_msg,%object
+longjmp_msg:
+	.string "longjmp causes uninitialized stack frame"
+	.size   longjmp_msg, .-longjmp_msg
+	.text
+
+# define CALL_FAIL						\
+	adrp	x0, longjmp_msg;				\
+	add	x0, x0, :lo12:longjmp_msg;			\
+	b	HIDDEN_JUMPTARGET(__fortify_fail)		\
+
+/* Jump to the position specified by ENV, causing the
+   setjmp call there to return VAL, or 1 if VAL is 0.
+   void __longjmp (__jmp_buf env, int val).  */
+        .text
+ENTRY(____longjmp_chk)
+	cfi_def_cfa(x0, 0)
+	cfi_offset(x19, JB_X19<<3)
+	cfi_offset(x20, JB_X20<<3)
+	cfi_offset(x21, JB_X21<<3)
+	cfi_offset(x22, JB_X22<<3)
+	cfi_offset(x23, JB_X23<<3)
+	cfi_offset(x24, JB_X24<<3)
+	cfi_offset(x25, JB_X25<<3)
+	cfi_offset(x26, JB_X26<<3)
+	cfi_offset(x27, JB_X27<<3)
+	cfi_offset(x28, JB_X28<<3)
+	cfi_offset(x29, JB_X29<<3)
+	cfi_offset(x30, JB_LR<<3)
+
+	cfi_offset( d8, JB_D8<<3)
+	cfi_offset( d9, JB_D9<<3)
+	cfi_offset(d10, JB_D10<<3)
+	cfi_offset(d11, JB_D11<<3)
+	cfi_offset(d12, JB_D12<<3)
+	cfi_offset(d13, JB_D13<<3)
+	cfi_offset(d14, JB_D14<<3)
+	cfi_offset(d15, JB_D15<<3)
+
+	PTR_ARG (0)
+
+	ldp	x19, x20, [x0, #JB_X19<<3]
+	ldp	x21, x22, [x0, #JB_X21<<3]
+	ldp	x23, x24, [x0, #JB_X23<<3]
+	ldp	x25, x26, [x0, #JB_X25<<3]
+	ldp	x27, x28, [x0, #JB_X27<<3]
+#ifdef PTR_DEMANGLE
+	ldp	x29,  x4, [x0, #JB_X29<<3]
+	PTR_DEMANGLE (30, 4, 3, 2)
+#else
+	ldp	x29, x30, [x0, #JB_X29<<3]
+#endif
+	/* longjmp probe takes 3 arguments, address of jump buffer as
+	   first argument (8@x0), return value as second argument (-4@x1),
+	   and target address (8@x30), respectively.  */
+	LIBC_PROBE (longjmp, 3, 8@x0, -4@x1, 8@x30)
+	ldp	 d8,  d9, [x0, #JB_D8<<3]
+	ldp	d10, d11, [x0, #JB_D10<<3]
+	ldp	d12, d13, [x0, #JB_D12<<3]
+	ldp	d14, d15, [x0, #JB_D14<<3]
+
+        /* Originally this was implemented with a series of
+	   .cfi_restore() directives.
+
+           The theory was that cfi_restore should revert to previous
+           frame value is the same as the current value.  In practice
+           this doesn't work, even after cfi_restore() gdb continues
+           to try to recover a previous frame value offset from x0,
+           which gets stuffed after a few more instructions.  The
+           cfi_same_value() mechanism appears to work fine.  */
+
+	cfi_same_value(x19)
+	cfi_same_value(x20)
+	cfi_same_value(x21)
+	cfi_same_value(x22)
+	cfi_same_value(x23)
+	cfi_same_value(x24)
+	cfi_same_value(x25)
+	cfi_same_value(x26)
+	cfi_same_value(x27)
+	cfi_same_value(x28)
+	cfi_same_value(x29)
+	cfi_same_value(x30)
+	cfi_same_value(d8)
+	cfi_same_value(d9)
+	cfi_same_value(d10)
+	cfi_same_value(d11)
+	cfi_same_value(d12)
+	cfi_same_value(d13)
+	cfi_same_value(d14)
+	cfi_same_value(d15)
+#ifdef PTR_DEMANGLE
+	ldr	x4, [x0, #JB_SP<<3]
+	PTR_DEMANGLE (5, 4, 3, 2)
+#else
+	ldr	x5, [x0, #JB_SP<<3]
+#endif
+
+	mrs	x3, tpidr_el0
+#if !defined (SHARED) || IS_IN (rtld)
+	cbz	x3, L(ok)	/* TLS not initialized yet */
+#endif
+	ldr	x3, [x3, #SIGSTATE_OFFSET]
+	cbz	x3, L(ok)	/* sigstate not initialized yet */
+
+	ldrb	w4, [x3, # (HURD_SIGSTATE__SIGALTSTACK__OFFSET + SIGALTSTACK__SS_FLAGS__OFFSET)]
+	tbnz	w4, #SS_ONSTACK_BIT, L(onstack)
+	/* We haven't been using an altstack.  Jumping to a higher-address
+	   frame is always allowed, otherwise it's not allowed.  */
+	mov	x6, sp
+	cmp	x5, x6
+	b.lt	L(ok)
+
+L(fail):
+	CALL_FAIL
+
+L(onstack):
+	/* We have been using an altstack.  Was it above or below ours? */
+	ldr	x2, [x3, # (HURD_SIGSTATE__SIGALTSTACK__OFFSET + SIGALTSTACK__SS_SP__OFFSET)]
+	cmp	x2, x5
+	b.lt	L(oks)		/* Jumping below the altstack, switch */
+	ldr	x6, [x3, # (HURD_SIGSTATE__SIGALTSTACK__OFFSET + SIGALTSTACK__SS_SIZE__OFFSET)]
+	add	x2, x2, x6
+	cmp	x2, x5
+	b.lt	L(ok)		/* Jumping inside the altstack, do not switch */
+
+	/* Jumping above the altstack, switch */
+L(oks):
+	and	w4, w4, #~(SS_ONSTACK)
+	str	w4, [x3, # (HURD_SIGSTATE__SIGALTSTACK__OFFSET + SIGALTSTACK__SS_FLAGS__OFFSET)]
+L(ok):
+	mov	sp, x5
+
+	/* longjmp_target probe takes 3 arguments, address of jump buffer
+	   as first argument (8@x0), return value as second argument (-4@x1),
+	   and target address (8@x30), respectively.  */
+	LIBC_PROBE (longjmp_target, 3, 8@x0, -4@x1, 8@x30)
+	cmp	x1, #0
+	mov	x0, #1
+	csel	x0, x1, x0, ne
+	/* Use br instead of ret because ret is guaranteed to mispredict */
+	br	x30
+END (____longjmp_chk)
diff --git a/sysdeps/mach/hurd/aarch64/__longjmp.S b/sysdeps/mach/hurd/aarch64/__longjmp.S
new file mode 100644
index 00000000..c9f2e1ce
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/__longjmp.S
@@ -0,0 +1,150 @@
+/* Copyright (C) 1997-2024 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 <asm-syntax.h>
+#include <jmpbuf-offsets.h>
+#include <pointer_guard.h>
+#include <tcb-offsets.h>
+#include <signal-defines.h>
+#include <stap-probe.h>
+#include <sysdep.h>
+
+#define SS_ONSTACK	1
+#define SS_ONSTACK_BIT	0
+
+/* __longjmp(jmpbuf, val) */
+
+ENTRY (__longjmp)
+	cfi_def_cfa(x0, 0)
+	cfi_offset(x19, JB_X19<<3)
+	cfi_offset(x20, JB_X20<<3)
+	cfi_offset(x21, JB_X21<<3)
+	cfi_offset(x22, JB_X22<<3)
+	cfi_offset(x23, JB_X23<<3)
+	cfi_offset(x24, JB_X24<<3)
+	cfi_offset(x25, JB_X25<<3)
+	cfi_offset(x26, JB_X26<<3)
+	cfi_offset(x27, JB_X27<<3)
+	cfi_offset(x28, JB_X28<<3)
+	cfi_offset(x29, JB_X29<<3)
+	cfi_offset(x30, JB_LR<<3)
+
+	cfi_offset( d8, JB_D8<<3)
+	cfi_offset( d9, JB_D9<<3)
+	cfi_offset(d10, JB_D10<<3)
+	cfi_offset(d11, JB_D11<<3)
+	cfi_offset(d12, JB_D12<<3)
+	cfi_offset(d13, JB_D13<<3)
+	cfi_offset(d14, JB_D14<<3)
+	cfi_offset(d15, JB_D15<<3)
+
+	PTR_ARG (0)
+
+	ldp	x19, x20, [x0, #JB_X19<<3]
+	ldp	x21, x22, [x0, #JB_X21<<3]
+	ldp	x23, x24, [x0, #JB_X23<<3]
+	ldp	x25, x26, [x0, #JB_X25<<3]
+	ldp	x27, x28, [x0, #JB_X27<<3]
+#ifdef PTR_DEMANGLE
+	ldp	x29,  x4, [x0, #JB_X29<<3]
+	PTR_DEMANGLE (30, 4, 3, 2)
+#else
+	ldp	x29, x30, [x0, #JB_X29<<3]
+#endif
+	/* longjmp probe takes 3 arguments, address of jump buffer as
+	   first argument (8@x0), return value as second argument (-4@x1),
+	   and target address (8@x30), respectively.  */
+	LIBC_PROBE (longjmp, 3, 8@x0, -4@x1, 8@x30)
+	ldp	 d8,  d9, [x0, #JB_D8<<3]
+	ldp	d10, d11, [x0, #JB_D10<<3]
+	ldp	d12, d13, [x0, #JB_D12<<3]
+	ldp	d14, d15, [x0, #JB_D14<<3]
+
+        /* Originally this was implemented with a series of
+	   .cfi_restore() directives.
+
+           The theory was that cfi_restore should revert to previous
+           frame value is the same as the current value.  In practice
+           this doesn't work, even after cfi_restore() gdb continues
+           to try to recover a previous frame value offset from x0,
+           which gets stuffed after a few more instructions.  The
+           cfi_same_value() mechanism appears to work fine.  */
+
+	cfi_same_value(x19)
+	cfi_same_value(x20)
+	cfi_same_value(x21)
+	cfi_same_value(x22)
+	cfi_same_value(x23)
+	cfi_same_value(x24)
+	cfi_same_value(x25)
+	cfi_same_value(x26)
+	cfi_same_value(x27)
+	cfi_same_value(x28)
+	cfi_same_value(x29)
+	cfi_same_value(x30)
+	cfi_same_value(d8)
+	cfi_same_value(d9)
+	cfi_same_value(d10)
+	cfi_same_value(d11)
+	cfi_same_value(d12)
+	cfi_same_value(d13)
+	cfi_same_value(d14)
+	cfi_same_value(d15)
+#ifdef PTR_DEMANGLE
+	ldr	x4, [x0, #JB_SP<<3]
+	PTR_DEMANGLE (5, 4, 3, 2)
+#else
+	ldr	x5, [x0, #JB_SP<<3]
+#endif
+
+	mrs	x3, tpidr_el0
+#if !defined (SHARED) || IS_IN (rtld)
+	cbz	x3, L(ok)	/* TLS not initialized yet */
+#endif
+	ldr	x3, [x3, #SIGSTATE_OFFSET]
+	cbz	x3, L(ok)	/* sigstate not initialized yet */
+	/* If we haven't been using an altstack, don't switch */
+	ldrb	w4, [x3, # (HURD_SIGSTATE__SIGALTSTACK__OFFSET + SIGALTSTACK__SS_FLAGS__OFFSET)]
+	tbz	w4, #SS_ONSTACK_BIT, L(ok)
+
+	/* We have been using an altstack.  Was it above or below ours? */
+	ldr	x2, [x3, # (HURD_SIGSTATE__SIGALTSTACK__OFFSET + SIGALTSTACK__SS_SP__OFFSET)]
+	cmp	x2, x5
+	b.lt	L(oks)		/* Jumping below the altstack, switch */
+	ldr	x6, [x3, # (HURD_SIGSTATE__SIGALTSTACK__OFFSET + SIGALTSTACK__SS_SIZE__OFFSET)]
+	add	x2, x2, x6
+	cmp	x2, x5
+	b.lt	L(ok)		/* Jumping inside the altstack, do not switch */
+
+	/* Jumping above the altstack, switch */
+L(oks):
+	and	w4, w4, #~(SS_ONSTACK)
+	str	w4, [x3, # (HURD_SIGSTATE__SIGALTSTACK__OFFSET + SIGALTSTACK__SS_FLAGS__OFFSET)]
+L(ok):
+	mov	sp, x5
+
+	/* longjmp_target probe takes 3 arguments, address of jump buffer
+	   as first argument (8@x0), return value as second argument (-4@x1),
+	   and target address (8@x30), respectively.  */
+	LIBC_PROBE (longjmp_target, 3, 8@x0, -4@x1, 8@x30)
+	cmp	x1, #0
+	mov	x0, #1
+	csel	x0, x1, x0, ne
+	/* Use br instead of ret because ret is guaranteed to mispredict */
+	br	x30
+END (__longjmp)
diff --git a/sysdeps/mach/hurd/aarch64/signal-defines.sym b/sysdeps/mach/hurd/aarch64/signal-defines.sym
new file mode 100644
index 00000000..e42bbbe0
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/signal-defines.sym
@@ -0,0 +1,10 @@
+#include <hurd/signal.h>
+#include <signal.h>
+
+--
+
+HURD_SIGSTATE__SIGALTSTACK__OFFSET	offsetof(struct hurd_sigstate, sigaltstack)
+
+SIGALTSTACK__SS_SP__OFFSET		offsetof(stack_t, ss_sp)
+SIGALTSTACK__SS_SIZE__OFFSET		offsetof(stack_t, ss_size)
+SIGALTSTACK__SS_FLAGS__OFFSET		offsetof(stack_t, ss_flags)
-- 
2.44.0

[PATCH v2 16/20] Add FPE_FLTIDO

[Sergey Bugaev]

This is a new si_code value for the SIGFPE signal that has been added
to FreeBSD, and is also going to be used on the Hurd.

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---

This makes sense, right?

We should probably define more codes still (see exception2signal in the
next patch).

 bits/siginfo-consts.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/bits/siginfo-consts.h b/bits/siginfo-consts.h
index 4eef775e..362a06a6 100644
--- a/bits/siginfo-consts.h
+++ b/bits/siginfo-consts.h
@@ -75,8 +75,10 @@ enum
 #  define FPE_FLTRES	FPE_FLTRES
   FPE_FLTINV,			/* Floating point invalid operation.  */
 #  define FPE_FLTINV	FPE_FLTINV
-  FPE_FLTSUB			/* Subscript out of range.  */
+  FPE_FLTSUB,			/* Subscript out of range.  */
 #  define FPE_FLTSUB	FPE_FLTSUB
+  FPE_FLTIDO			/* Input denormal operation.  */
+#  define FPE_FLTIDO	FPE_FLTIDO
 };
 
 /* `si_code' values for SIGSEGV signal.  */
-- 
2.44.0

[PATCH v2 17/20] hurd: Add an AArch64 signal implementation

[Sergey Bugaev]

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 sysdeps/mach/hurd/aarch64/Makefile          |   4 +
 sysdeps/mach/hurd/aarch64/bits/sigcontext.h |  96 ++++++
 sysdeps/mach/hurd/aarch64/exc2signal.c      | 149 +++++++++
 sysdeps/mach/hurd/aarch64/intr-msg.h        | 123 ++++++++
 sysdeps/mach/hurd/aarch64/sigreturn.c       | 127 ++++++++
 sysdeps/mach/hurd/aarch64/trampoline.c      | 325 ++++++++++++++++++++
 6 files changed, 824 insertions(+)
 create mode 100644 sysdeps/mach/hurd/aarch64/bits/sigcontext.h
 create mode 100644 sysdeps/mach/hurd/aarch64/exc2signal.c
 create mode 100644 sysdeps/mach/hurd/aarch64/intr-msg.h
 create mode 100644 sysdeps/mach/hurd/aarch64/sigreturn.c
 create mode 100644 sysdeps/mach/hurd/aarch64/trampoline.c

diff --git a/sysdeps/mach/hurd/aarch64/Makefile b/sysdeps/mach/hurd/aarch64/Makefile
index 9210d436..6cc831d6 100644
--- a/sysdeps/mach/hurd/aarch64/Makefile
+++ b/sysdeps/mach/hurd/aarch64/Makefile
@@ -22,3 +22,7 @@ endif
 ifeq ($(subdir),setjmp)
 gen-as-const-headers += signal-defines.sym
 endif
+
+ifeq ($(subdir),signal)
+CFLAGS-sigreturn.c += -mgeneral-regs-only
+endif
diff --git a/sysdeps/mach/hurd/aarch64/bits/sigcontext.h b/sysdeps/mach/hurd/aarch64/bits/sigcontext.h
new file mode 100644
index 00000000..163523fa
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/bits/sigcontext.h
@@ -0,0 +1,96 @@
+/* Machine-dependent signal context structure for GNU Hurd.  AArch64 version.
+   Copyright (C) 1991-2024 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/>.  */
+
+#ifndef _BITS_SIGCONTEXT_H
+#define _BITS_SIGCONTEXT_H 1
+
+#if !defined _SIGNAL_H && !defined _SYS_UCONTEXT_H
+# error "Never use <bits/sigcontext.h> directly; include <signal.h> instead."
+#endif
+
+/* Signal handlers are actually called:
+   void handler (int sig, int code, struct sigcontext *scp);  */
+
+#include <bits/types/__sigset_t.h>
+#include <mach/machine/fp_reg.h>
+
+/* State of this thread when the signal was taken.  */
+struct sigcontext
+  {
+    /* These first members are machine-independent.  */
+
+    int sc_onstack;		/* Nonzero if running on sigstack.  */
+    __sigset_t sc_mask;		/* Blocked signals to restore.  */
+
+    /* MiG reply port this thread is using.  */
+    unsigned int sc_reply_port;
+
+    /* Port this thread is doing an interruptible RPC on.  */
+    unsigned int sc_intr_port;
+
+    /* Error code associated with this signal (interpreted as `error_t').  */
+    int sc_error;
+
+    /* Make sure the below members are properly aligned, and not packed
+       together with sc_error -- otherwise the layout won't match that of
+       aarch64_thread_state.  */
+    int sc_pad1;
+
+    /* All following members are machine-dependent.  The rest of this
+       structure is written to be laid out identically to:
+       {
+	 struct aarch64_thread_state basic;
+	 struct aarch64_float_state fpu;
+       }
+       trampoline.c knows this, so it must be changed if this changes.  */
+
+#define sc_aarch64_thread_state sc_x[0] /* Beginning of correspondence.  */
+    long sc_x[31];
+    long sc_sp;
+    long sc_pc;
+    long sc_tpidr_el0;
+    long sc_cpsr;
+
+#define sc_aarch64_float_state sc_v[0]
+    __int128_t sc_v[32];
+    long sc_fpsr;
+    long sc_fpcr;
+  };
+
+/* Traditional BSD names for some members.  */
+#define sc_fp	sc_x[29]	/* Frame pointer.  */
+#define sc_ps	sc_cpsr
+
+
+/* The deprecated sigcode values below are passed as an extra, non-portable
+   argument to regular signal handlers.  You should use SA_SIGINFO handlers
+   instead, which use the standard POSIX signal codes.  */
+
+/* Codes for SIGFPE.  */
+#define FPE_INTOVF_TRAP		0x1 /* integer overflow */
+#define FPE_INTDIV_FAULT	0x2 /* integer divide by zero */
+#define FPE_FLTOVF_FAULT	0x3 /* floating overflow */
+#define FPE_FLTDIV_FAULT	0x4 /* floating divide by zero */
+#define FPE_FLTUND_FAULT	0x5 /* floating underflow */
+#define FPE_SUBRNG_FAULT	0x7 /* BOUNDS instruction failed */
+#define FPE_FLTDNR_FAULT	0x8 /* denormalized operand */
+#define FPE_FLTINX_FAULT	0x9 /* floating loss of precision */
+#define FPE_EMERR_FAULT		0xa /* mysterious emulation error 33 */
+#define FPE_EMBND_FAULT		0xb /* emulation BOUNDS instruction failed */
+
+#endif /* bits/sigcontext.h */
diff --git a/sysdeps/mach/hurd/aarch64/exc2signal.c b/sysdeps/mach/hurd/aarch64/exc2signal.c
new file mode 100644
index 00000000..7027bbf7
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/exc2signal.c
@@ -0,0 +1,149 @@
+/* Translate Mach exception codes into signal numbers.  AArch64 version.
+   Copyright (C) 1991-2024 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 <hurd.h>
+#include <hurd/signal.h>
+#include <mach/exception.h>
+
+/* Translate the Mach exception codes, as received in an `exception_raise' RPC,
+   into a signal number and signal subcode.  */
+
+static void
+exception2signal (struct hurd_signal_detail *detail, int *signo, int posix)
+{
+  detail->error = 0;
+
+  switch (detail->exc)
+    {
+    default:
+      *signo = SIGIOT;
+      detail->code = detail->exc;
+      break;
+
+    case EXC_BAD_ACCESS:
+      switch (detail->exc_code)
+        {
+	case KERN_INVALID_ADDRESS:
+	case KERN_MEMORY_FAILURE:
+	  *signo = SIGSEGV;
+	  detail->code = posix ? SEGV_MAPERR : detail->exc_subcode;
+	  break;
+
+	case KERN_PROTECTION_FAILURE:
+	case KERN_WRITE_PROTECTION_FAILURE:
+	  *signo = SIGSEGV;
+	  detail->code = posix ? SEGV_ACCERR : detail->exc_subcode;
+	  break;
+
+	case EXC_AARCH64_MTE:
+	  *signo = SIGSEGV;
+	  /* TODO: Should be SEGV_MTESERR */
+	  detail->code = posix ? SEGV_ACCERR : detail->exc_subcode;
+	  break;
+
+	case EXC_AARCH64_BTI:
+	  *signo = SIGILL;
+	  /* XXX: Consider adopting ILL_BTCFI from OpenBSD.  */
+	  /* XXX: exc_subcode / signal code contains BTYPE */
+	  detail->code = posix ? ILL_ILLOPN : detail->exc_subcode;
+	  break;
+
+	case EXC_AARCH64_AL:
+	case EXC_AARCH64_AL_PC:
+	case EXC_AARCH64_AL_SP:
+	  *signo = SIGBUS;
+	  detail->code = posix ? BUS_ADRALN : detail->exc_subcode;
+	  break;
+
+	default:
+	  *signo = SIGBUS;
+	  detail->code = posix ? BUS_ADRERR : detail->exc_subcode;
+	  break;
+	}
+      detail->error = detail->exc_code;
+      break;
+
+    case EXC_BAD_INSTRUCTION:
+      *signo = SIGILL;
+      switch (detail->exc_code)
+        {
+        case EXC_AARCH64_SVC:
+          detail->code = posix ? ILL_ILLTRP : 0;
+          break;
+
+	default:
+	  detail->code = posix ? ILL_ILLOPC : 0;
+	  break;
+        }
+      break;
+
+    case EXC_ARITHMETIC:
+      *signo = SIGFPE;
+      switch (detail->exc_code)
+	{
+	case EXC_AARCH64_IDF:
+	  detail->code = posix ? FPE_FLTIDO : 0;
+	  break;
+	case EXC_AARCH64_IXF:
+	  detail->code = posix ? FPE_FLTRES : FPE_FLTINX_FAULT;
+	  break;
+	case EXC_AARCH64_UFF:
+	  detail->code = posix ? FPE_FLTUND : FPE_FLTDNR_FAULT;
+	  break;
+	case EXC_AARCH64_OFF:
+	  detail->code = posix ? FPE_FLTOVF : FPE_FLTOVF_FAULT;
+	  break;
+	case EXC_AARCH64_DZF:
+	  detail->code = posix ? FPE_FLTDIV : FPE_FLTDIV_FAULT;
+	  break;
+	case EXC_AARCH64_IOF:
+	  /* NB: We used to send SIGILL here but we can't distinguish
+	     POSIX vs. legacy with respect to what signal we send.  */
+	  detail->code = posix ? FPE_FLTINV : 0 /*ILL_FPEOPR_FAULT*/;
+	  break;
+	default:
+	  detail->code = 0;
+	}
+      break;
+
+    case EXC_EMULATION:
+    case EXC_SOFTWARE:
+      *signo = SIGEMT;
+      detail->code = 0;
+      break;
+
+
+    case EXC_BREAKPOINT:
+      *signo = SIGTRAP;
+      detail->code = posix ? TRAP_BRKPT : 0;
+      break;
+    }
+}
+libc_hidden_def (_hurd_exception2signal)
+
+void
+_hurd_exception2signal (struct hurd_signal_detail *detail, int *signo)
+{
+  exception2signal (detail, signo, 1);
+}
+
+void
+_hurd_exception2signal_legacy (struct hurd_signal_detail *detail, int *signo)
+{
+  exception2signal (detail, signo, 0);
+}
diff --git a/sysdeps/mach/hurd/aarch64/intr-msg.h b/sysdeps/mach/hurd/aarch64/intr-msg.h
new file mode 100644
index 00000000..b511d7d7
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/intr-msg.h
@@ -0,0 +1,123 @@
+/* Machine-dependent details of interruptible RPC messaging.  AArch64 version.
+   Copyright (C) 1995-2024 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/>.  */
+
+
+/* Note that we must mark OPTION and TIMEOUT as outputs of this operation,
+   to indicate that the signal thread might mutate them as part
+   of sending us to a signal handler.  */
+
+#define INTR_MSG_TRAP(msg, option, send_size, rcv_size, rcv_name, timeout, notify, cancel_p, intr_port_p) \
+({									      \
+  register uintptr_t /* error_t */ err asm ("x0");			      \
+  register uintptr_t option_x1 asm ("x1") = option;			      \
+  register uintptr_t send_size_x2 asm ("x2") = send_size;		      \
+  register uintptr_t rcv_size_x3 asm ("x3") = rcv_size;			      \
+  register uintptr_t rcv_name_x4 asm ("x4") = rcv_name;			      \
+  register uintptr_t timeout_x5 asm ("x5") = timeout;			      \
+  register uintptr_t notify_x6 asm ("x6") = notify;			      \
+  register void *msg_x9 asm ("x9") = msg;  /* used by trampoline.c */	      \
+  asm volatile ("\n"							      \
+       ".globl _hurd_intr_rpc_msg_about_to\n"				      \
+       ".globl _hurd_intr_rpc_msg_setup_done\n"				      \
+       ".globl _hurd_intr_rpc_msg_in_trap\n"				      \
+       /* Clear x0 before we do the check for cancel below.  This is to
+          detect x0 being set to non-zero (actually MACH_SEND_INTERRUPTED)
+          from the outside (namely, _hurdsig_abort_rpcs), which signals us
+          to skip the trap we were about to enter.  */			      \
+       "	mov %[err], #0\n"					      \
+       "_hurd_intr_rpc_msg_about_to:\n"					      \
+       /* We need to make a last check of cancel, in case we got interrupted
+          right before _hurd_intr_rpc_msg_about_to.  */			      \
+       "	ldr w8, %[cancel]\n"					      \
+       "	cbz w8, _hurd_intr_rpc_msg_do\n"			      \
+       /* We got interrupted, note so and return EINTR.  */		      \
+       "	str wzr, %[intr_port]\n"				      \
+       "	mov %[err], %[eintr_lo]\n"				      \
+       "	movk %[err], %[eintr_hi], lsl 16\n"			      \
+       "	b _hurd_intr_rpc_msg_sp_restored\n"			      \
+       "_hurd_intr_rpc_msg_do:\n"					      \
+       /* Ok, prepare the mach_msg_trap arguments.  We pass all the 7 args
+          in registers.  */						      \
+       "_hurd_intr_rpc_msg_setup_done:\n"				      \
+       /* From here on, it is safe to make us jump over the syscall.  Now
+          check if we have been told to skip the syscall while running
+          the above.  */						      \
+       "	cbnz %[err], _hurd_intr_rpc_msg_in_trap\n"		      \
+       /* Do the actual syscall.  */					      \
+       "	mov %[err], %[msg]\n"					      \
+       "	mov x8, #-25\n"						      \
+       "_hurd_intr_rpc_msg_do_trap:\n"					      \
+       "	svc #0\n" /* status in %[err] */			      \
+       "_hurd_intr_rpc_msg_in_trap:\n"					      \
+       "_hurd_intr_rpc_msg_sp_restored:\n"				      \
+       : [err] "=r" (err), "+r" (option_x1),				      \
+         [intr_port] "=m" (*intr_port_p),				      \
+         "+r" (timeout_x5)						      \
+       : [msg] "r" (msg_x9), "r" (send_size_x2), "r" (rcv_size_x3),	      \
+         "r" (rcv_name_x4), "r" (notify_x6),				      \
+         [cancel] "m" (*cancel_p),					      \
+         [eintr_lo] "i" (EINTR & 0xffff), [eintr_hi] "i" (EINTR >> 16));      \
+  option = option_x1;							      \
+  timeout = timeout_x5;							      \
+  err;									      \
+})
+\f
+#include "hurdfault.h"
+
+/* This cannot be an inline function because it calls setjmp.  */
+#define SYSCALL_EXAMINE(state, callno)					      \
+({									      \
+  int result;								      \
+  unsigned int *p = (unsigned int *) (state)->pc - 4;			      \
+  if (_hurdsig_catch_memory_fault (p))					      \
+    return 0;								      \
+  if (result = (*p == 0xd4000001))					      \
+    /* The PC is just after a "svc #0" instruction.
+       This is a system call in progress; x8 holds the call number.  */	      \
+    *(callno) = (state)->x[8];						      \
+  _hurdsig_end_catch_fault ();						      \
+  result;								      \
+})
+
+
+/* This cannot be an inline function because it calls setjmp.  */
+#define MSG_EXAMINE(state, msgid, rcvname, send_name, opt, tmout)	      \
+({									      \
+  int ret = 0;								      \
+  const struct machine_thread_state *s = (state);			      \
+  const mach_msg_header_t *msg = (const void *) s->x[0];		      \
+  *(opt) = s->x[1];							      \
+  *(rcvname) = s->x[4];							      \
+  *(tmout) = s->x[5];							      \
+  if (msg == 0)								      \
+    {									      \
+      *(send_name) = MACH_PORT_NULL;					      \
+      *(msgid) = 0;							      \
+    }									      \
+  else									      \
+    {									      \
+      ret = _hurdsig_catch_memory_fault (msg) ? -1 : 0;			      \
+      if (ret == 0)							      \
+        {								      \
+          *(send_name) = msg->msgh_remote_port;				      \
+          *(msgid) = msg->msgh_id;					      \
+          _hurdsig_end_catch_fault ();					      \
+        }								      \
+    }									      \
+  ret;									      \
+})
diff --git a/sysdeps/mach/hurd/aarch64/sigreturn.c b/sysdeps/mach/hurd/aarch64/sigreturn.c
new file mode 100644
index 00000000..c58b9c49
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/sigreturn.c
@@ -0,0 +1,127 @@
+/* Copyright (C) 1991-2024 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 <hurd.h>
+#include <hurd/signal.h>
+#include <hurd/msg.h>
+#include <stdlib.h>
+
+/* This is run on the thread stack after restoring it, to be able to
+   unlock SS off sigstack.  */
+void
+__sigreturn2 (struct sigcontext *scp,
+	      struct hurd_sigstate *ss)
+{
+  error_t err;
+  mach_port_t reply_port;
+  _hurd_sigstate_unlock (ss);
+
+  /* Destroy the MiG reply port used by the signal handler, and restore the
+     reply port in use by the thread when interrupted.
+
+     We cannot use the original reply port for our RPCs that we do here, since
+     we could unexpectedly receive/consume a reply message meant for the user
+     (in particular, msg_sig_post_reply), and also since we would deallocate
+     the port if *our* RPC fails, which we don't want to do since the user
+     still has the old name.  And so, temporarily set MACH_PORT_DEAD as our
+     reply name, and make sure destroying the port is the very last RPC we
+     do.  */
+  reply_port = THREAD_GETMEM (THREAD_SELF, reply_port);
+  THREAD_SETMEM (THREAD_SELF, reply_port, MACH_PORT_DEAD);
+  if (__glibc_likely (MACH_PORT_VALID (reply_port)))
+    (void) __mach_port_mod_refs (__mach_task_self (), reply_port,
+                                 MACH_PORT_RIGHT_RECEIVE, -1);
+  THREAD_SETMEM (THREAD_SELF, reply_port, scp->sc_reply_port);
+
+  /* Restore thread state.  */
+  err = __thread_set_self_state (AARCH64_FLOAT_STATE,
+				 (thread_state_t) &scp->sc_aarch64_float_state,
+				 AARCH64_FLOAT_STATE_COUNT);
+  assert_perror (err);
+  err = __thread_set_self_state (AARCH64_THREAD_STATE,
+				 (thread_state_t) &scp->sc_aarch64_thread_state,
+				 AARCH64_THREAD_STATE_COUNT);
+  assert_perror (err);
+  __builtin_unreachable ();
+}
+
+int
+__sigreturn (struct sigcontext *scp)
+{
+  struct hurd_sigstate *ss;
+  struct hurd_userlink *link = (void *) &scp[1];
+  uintptr_t usp;
+
+  if (__glibc_unlikely (scp == NULL || (scp->sc_mask & _SIG_CANT_MASK)))
+    return __hurd_fail (EINVAL);
+
+  ss = _hurd_self_sigstate ();
+  _hurd_sigstate_lock (ss);
+
+  /* Remove the link on the `active resources' chain added by
+     _hurd_setup_sighandler.  Its purpose was to make sure
+     that we got called; now we have, it is done.  */
+  _hurd_userlink_unlink (link);
+
+  /* Restore the set of blocked signals, and the intr_port slot.  */
+  ss->blocked = scp->sc_mask;
+  ss->intr_port = scp->sc_intr_port;
+
+  /* Check for pending signals that were blocked by the old set.  */
+  if (_hurd_sigstate_pending (ss) & ~ss->blocked)
+    {
+      /* There are pending signals that just became unblocked.  Wake up the
+	 signal thread to deliver them.  But first, squirrel away SCP where
+	 the signal thread will notice it if it runs another handler, and
+	 arrange to have us called over again in the new reality.  */
+      ss->context = scp;
+      _hurd_sigstate_unlock (ss);
+      __msg_sig_post (_hurd_msgport, 0, 0, __mach_task_self ());
+      /* If a pending signal was handled, sig_post never returned.
+	 If it did return, the pending signal didn't run a handler;
+	 proceed as usual.  */
+      _hurd_sigstate_lock (ss);
+      ss->context = NULL;
+    }
+
+  if (scp->sc_onstack)
+    ss->sigaltstack.ss_flags &= ~SS_ONSTACK;
+
+  /* Copy the signal context onto the user's stack, to be able to release the
+     altstack (by unlocking sigstate).  Note that unless an altstack is used,
+     the sigcontext will itself be located on the user's stack, so we may well
+     be overwriting it here (or later in __sigreturn2).  */
+
+  usp = ALIGN_DOWN(scp->sc_sp - sizeof (struct sigcontext), 16);
+  memmove ((void *) usp, scp, sizeof (struct sigcontext));
+
+  /* Switch to the user's stack that we have just prepared, and call
+     __sigreturn2.  Clobber "memory" to make sure GCC flushes the stack
+     setup to actual memory.  */
+  {
+    register uintptr_t usp_x0 asm("x0") = usp;
+    register struct hurd_sigstate *ss_x1 asm("x1") = ss;
+
+    asm volatile ("mov sp, %0\n"
+		  "b __sigreturn2"
+		  :: "r" (usp_x0), "r" (ss_x1)
+		  : "memory");
+    __builtin_unreachable ();
+  }
+}
+
+weak_alias (__sigreturn, sigreturn)
diff --git a/sysdeps/mach/hurd/aarch64/trampoline.c b/sysdeps/mach/hurd/aarch64/trampoline.c
new file mode 100644
index 00000000..4b301335
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/trampoline.c
@@ -0,0 +1,325 @@
+/* Set thread_state for sighandler, and sigcontext to recover.  AArch64 version.
+   Copyright (C) 1994-2024 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 <hurd/signal.h>
+#include <hurd/userlink.h>
+#include <thread_state.h>
+#include <mach/exception.h>
+#include <assert.h>
+#include <errno.h>
+#include "hurdfault.h"
+#include <sys/ucontext.h>
+
+
+/* Fill in a siginfo_t structure for SA_SIGINFO-enabled handlers.  */
+static void fill_siginfo (siginfo_t *si, int signo,
+			  const struct hurd_signal_detail *detail,
+			  const struct machine_thread_all_state *state)
+{
+  si->si_signo = signo;
+  si->si_errno = detail->error;
+  si->si_code = detail->code;
+
+  /* XXX We would need a protocol change for sig_post to include
+   * this information.  */
+  si->si_pid = -1;
+  si->si_uid = -1;
+
+  /* Address of the faulting instruction or memory access.  */
+  if (detail->exc == EXC_BAD_ACCESS)
+    si->si_addr = (void *) detail->exc_subcode;
+  else
+    si->si_addr = (void *) state->basic.pc;
+
+  /* XXX On SIGCHLD, this should be the exit status of the child
+   * process.  We would need a protocol change for the proc server
+   * to send this information along with the signal.  */
+  si->si_status = 0;
+
+  si->si_band = 0;              /* SIGPOLL is not supported yet.  */
+  si->si_value.sival_int = 0;   /* sigqueue() is not supported yet.  */
+}
+
+/* Fill in a ucontext_t structure SA_SIGINFO-enabled handlers.  */
+static void fill_ucontext (ucontext_t *uc, const struct sigcontext *sc)
+{
+  uc->uc_flags = 0;
+  uc->uc_link = NULL;
+  uc->uc_sigmask = sc->sc_mask;
+  uc->uc_stack.ss_sp = (__ptr_t) sc->sc_sp;
+  uc->uc_stack.ss_size = 0;
+  uc->uc_stack.ss_flags = 0;
+
+  memcpy (&uc->uc_mcontext.gregs, &sc->sc_aarch64_thread_state,
+	  sizeof (struct aarch64_thread_state));
+  memcpy (&uc->uc_mcontext.fpregs, &sc->sc_aarch64_float_state,
+	  sizeof (struct aarch64_float_state));
+}
+
+struct sigcontext *
+_hurd_setup_sighandler (struct hurd_sigstate *ss, const struct sigaction *action,
+			__sighandler_t handler,
+			int signo, struct hurd_signal_detail *detail,
+			int rpc_wait,
+			struct machine_thread_all_state *state)
+{
+  void trampoline (void) attribute_hidden;
+  void rpc_wait_trampoline (void) attribute_hidden;
+  void *sigsp;
+  struct sigcontext *scp;
+  struct
+    {
+      union
+        {
+          int signo;
+          /* Make sure signo takes up a pointer-sized slot on the stack.
+             (This should already be the case considering the siginfop
+             pointer below, but better be explicit.)  */
+          void *_pointer_sized;
+        };
+      union
+	{
+	  /* Extra arguments for traditional signal handlers */
+	  struct
+	    {
+	      long int sigcode;
+	      struct sigcontext *scp;       /* Points to ctx, below.  */
+	    } legacy;
+
+	  /* Extra arguments for SA_SIGINFO handlers */
+	  struct
+	    {
+	      siginfo_t *siginfop;          /* Points to siginfo, below.  */
+	      ucontext_t *uctxp;            /* Points to uctx, below.  */
+	    } posix;
+	};
+
+      void *_pad;
+
+      /* NB: sigreturn assumes link is next to ctx.  */
+      struct sigcontext ctx;
+      struct hurd_userlink link;
+      ucontext_t ucontext;
+      siginfo_t siginfo;
+    } *stackframe;
+
+  if (ss->context)
+    {
+      /* We have a previous sigcontext that sigreturn was about
+	 to restore when another signal arrived.  We will just base
+	 our setup on that.  */
+      if (! _hurdsig_catch_memory_fault (ss->context))
+	{
+	  memcpy (&state->basic, &ss->context->sc_aarch64_thread_state,
+		  sizeof (state->basic));
+	  memcpy (&state->fpu, &ss->context->sc_aarch64_float_state,
+		  sizeof (state->fpu));
+	  state->set |= (1 << AARCH64_THREAD_STATE) | (1 << AARCH64_FLOAT_STATE);
+	}
+    }
+
+  if (! machine_get_basic_state (ss->thread, state))
+    return NULL;
+
+  if ((action->sa_flags & SA_ONSTACK)
+      && !(ss->sigaltstack.ss_flags & (SS_DISABLE|SS_ONSTACK)))
+    {
+      sigsp = ss->sigaltstack.ss_sp + ss->sigaltstack.ss_size;
+      ss->sigaltstack.ss_flags |= SS_ONSTACK;
+    }
+  else
+    /* No red zone on aarch64-gnu.  */
+    sigsp = (void *) state->basic.sp;
+
+  /* Push the arguments to call `trampoline' on the stack.
+     Note that user's SP doesn't strictly have to be 16-aligned, since
+     AArch64 only requires 16-alignment for the stack pointer when
+     making accesses relative to it.  */
+  sigsp = PTR_ALIGN_DOWN (sigsp - sizeof (*stackframe), 16);
+  stackframe = sigsp;
+
+  _Static_assert ((void *) (&stackframe->_pad + 1) == (void *) &stackframe->ctx,
+		  "trampoline expects no extra padding between "
+		  "_pad and ctx");
+
+  if (_hurdsig_catch_memory_fault (stackframe))
+    {
+      /* We got a fault trying to write the stack frame.
+	 We cannot set up the signal handler.
+	 Returning NULL tells our caller, who will nuke us with a SIGILL.  */
+      return NULL;
+    }
+  else
+    {
+      int ok;
+
+      extern void _hurdsig_longjmp_from_handler (void *, jmp_buf, int);
+
+      /* Add a link to the thread's active-resources list.  We mark this as
+	 the only user of the "resource", so the cleanup function will be
+	 called by any longjmp which is unwinding past the signal frame.
+	 The cleanup function (in sigunwind.c) will make sure that all the
+	 appropriate cleanups done by sigreturn are taken care of.  */
+      stackframe->link.cleanup = &_hurdsig_longjmp_from_handler;
+      stackframe->link.cleanup_data = &stackframe->ctx;
+      stackframe->link.resource.next = NULL;
+      stackframe->link.resource.prevp = NULL;
+      stackframe->link.thread.next = ss->active_resources;
+      stackframe->link.thread.prevp = &ss->active_resources;
+      if (stackframe->link.thread.next)
+	stackframe->link.thread.next->thread.prevp
+	  = &stackframe->link.thread.next;
+      ss->active_resources = &stackframe->link;
+
+      /* Set up the sigcontext from the current state of the thread.  */
+
+      scp = &stackframe->ctx;
+      scp->sc_onstack = ss->sigaltstack.ss_flags & SS_ONSTACK ? 1 : 0;
+
+      /* struct sigcontext is laid out so that starting at sc_x[0] mimics a
+	 struct aarch64_thread_state.  */
+      _Static_assert (offsetof (struct sigcontext, sc_aarch64_thread_state)
+		      % __alignof__ (struct aarch64_thread_state) == 0,
+		      "sc_aarch64_thread_state layout mismatch");
+      memcpy (&scp->sc_aarch64_thread_state,
+	      &state->basic, sizeof (state->basic));
+
+      /* struct sigcontext is laid out so that starting at sc_v[0] mimics a
+	 struct aarch64_float_state.  */
+      _Static_assert (offsetof (struct sigcontext, sc_aarch64_float_state)
+		      % __alignof__ (struct aarch64_float_state) == 0,
+		      "sc_aarch64_float_state layout mismatch");
+      ok = machine_get_state (ss->thread, state, AARCH64_FLOAT_STATE,
+			      &state->fpu, &scp->sc_aarch64_float_state,
+			      sizeof (state->fpu));
+
+      /* Set up the arguments for the signal handler.  */
+      stackframe->signo = signo;
+      if (action->sa_flags & SA_SIGINFO)
+	{
+	  stackframe->posix.siginfop = &stackframe->siginfo;
+	  stackframe->posix.uctxp = &stackframe->ucontext;
+	  fill_siginfo (&stackframe->siginfo, signo, detail, state);
+	  fill_ucontext (&stackframe->ucontext, scp);
+	}
+      else
+	{
+	  if (detail->exc)
+	    {
+	      int nsigno;
+	      _hurd_exception2signal_legacy (detail, &nsigno);
+	      assert (nsigno == signo);
+	    }
+	  else
+	    detail->code = 0;
+
+	  stackframe->legacy.sigcode = detail->code;
+	  stackframe->legacy.scp = &stackframe->ctx;
+	}
+
+      _hurdsig_end_catch_fault ();
+
+      if (!ok)
+	return NULL;
+    }
+
+  /* Modify the thread state to call the trampoline code on the new stack.  */
+  state->basic.sp = (uintptr_t) sigsp;
+
+  if (rpc_wait)
+    {
+      /* The signalee thread was blocked in a mach_msg_trap system call,
+         still waiting for a reply.  We will have it run the special
+         trampoline code which retries the message receive before running
+         the signal handler.
+
+         To do this we change the OPTION argument (in x1) to enable only
+         message reception, since the request message has already been
+         sent.  */
+
+      assert (state->basic.x[1] & MACH_RCV_MSG);
+      /* Disable the message-send, since it has already completed.  The
+         calls we retry need only wait to receive the reply message.  */
+      state->basic.x[1] &= ~MACH_SEND_MSG;
+
+      /* Limit the time to receive the reply message, in case the server
+         claimed that `interrupt_operation' succeeded but in fact the RPC
+         is hung.  */
+      state->basic.x[1] |= MACH_RCV_TIMEOUT;
+      state->basic.x[5] = _hurd_interrupted_rpc_timeout;
+
+      state->basic.pc = (uintptr_t) rpc_wait_trampoline;
+      /* After doing the message receive, the trampoline code will need to
+         update the x0 value to be restored by sigreturn.  To simplify
+         the assembly code, we pass the address of its slot in SCP to the
+         trampoline code in x21.  */
+      state->basic.x[21] = (uintptr_t) &scp->sc_x[0];
+    }
+  else
+    state->basic.pc = (uintptr_t) trampoline;
+
+  /* We pass the handler function to the trampoline code in x20.  */
+  state->basic.x[20] = (uintptr_t) handler;
+
+  /* Clear pstate, notably reset BTYPE to 0.  */
+  state->basic.cpsr = 0;
+
+  return scp;
+}
+
+asm ("rpc_wait_trampoline:\n"
+  /* This is the entry point when we have an RPC reply message to receive
+     before running the handler.  The MACH_MSG_SEND bit has already been
+     cleared in the OPTION argument in our x1.  For our convenience, x21
+     points to the sc_x[0] member of the sigcontext.
+
+     When the sigcontext was saved, x0 was MACH_RCV_INTERRUPTED.  To repeat
+     the message call, we need to restore the original message buffer
+     pointer; intr-msg.h keeps a backup copy of it in x9 specifically for
+     this purpose.  */
+     "mov x0, x9\n"
+     "svc #0\n"
+     /* Now the message receive has completed and the original caller of
+        the RPC (i.e. the code running when the signal arrived) needs to
+        see the final return value of the message receive in x0.  So store
+        the new x0 value into the sc_x[0] member of the sigcontext (whose
+        address is in x21 to make this code simpler).  */
+     "str x0, [x21]\n"
+
+     "trampoline:\n"
+     /* Entry point for running the handler normally.  The arguments to the
+        handler function are on the top of the stack:
+
+        [sp]		SIGNO
+        [sp, #8]	SIGCODE
+        [sp, #16]	SCP
+        [sp, #24]	_pad
+
+        Pop them off to the registers, to pass as arguments to the handler.
+     */
+     "ldp x0, x1, [sp], #16\n"
+     "ldr x2, [sp], #16\n"
+     /* Call handler (signo, sigcode, scp).  Note that this is an indirect
+        call not using x16/x17, so this requires the signal handler to start
+        with a proper "bti c" marker.  */
+     "blr x20\n"
+     /* Call __sigreturn (), passing &CTX as SCP.  CTX is on the top of
+        the stack.  If __sigreturn () fails, we're in trouble.  */
+     "mov x0, sp\n"
+     "bl __sigreturn\n"
+     "udf #0xdead");
-- 
2.44.0

[PATCH v2 18/20] htl: Implement some support for TLS_DTV_AT_TP

[Sergey Bugaev]

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 htl/pt-create.c                     |  2 ++
 sysdeps/htl/dl-thread_gscope_wait.c | 16 ++++++++++++++--
 sysdeps/mach/hurd/htl/pt-sysdep.c   |  9 +++++++++
 3 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/htl/pt-create.c b/htl/pt-create.c
index fac61f1b..8a735d99 100644
--- a/htl/pt-create.c
+++ b/htl/pt-create.c
@@ -177,7 +177,9 @@ __pthread_create_internal (struct __pthread **thread,
       err = ENOMEM;
       goto failed_thread_tls_alloc;
     }
+#if TLS_TCB_AT_TP
   pthread->tcb->tcb = pthread->tcb;
+#endif
 
   /* And initialize the rest of the machine context.  This may include
      additional machine- and system-specific initializations that
diff --git a/sysdeps/htl/dl-thread_gscope_wait.c b/sysdeps/htl/dl-thread_gscope_wait.c
index 90a9a798..ee0a3165 100644
--- a/sysdeps/htl/dl-thread_gscope_wait.c
+++ b/sysdeps/htl/dl-thread_gscope_wait.c
@@ -20,6 +20,18 @@
 #include <pthread.h>
 #include <htl/pt-internal.h>
 
+static inline int *
+thread_gscope_flag (struct __pthread *t)
+{
+#if TLS_TCB_AT_TP
+  return &t->tcb->gscope_flag;
+#elif TLS_DTV_AT_TP
+  return &((tcbprehead_t *) t->tcb - 1)->gscope_flag;
+#else
+# error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
+#endif
+}
+
 void
 __thread_gscope_wait (void)
 {
@@ -33,10 +45,10 @@ __thread_gscope_wait (void)
   for (i = 0; i < GL (dl_pthread_num_threads); ++i)
     {
       t = GL (dl_pthread_threads[i]);
-      if (t == NULL || t->tcb->gscope_flag == THREAD_GSCOPE_FLAG_UNUSED)
+      if (t == NULL || *thread_gscope_flag (t) == THREAD_GSCOPE_FLAG_UNUSED)
         continue;
 
-      gscope_flagp = &t->tcb->gscope_flag;
+      gscope_flagp = thread_gscope_flag (t);
 
       /* We have to wait until this thread is done with the global
          scope.  First tell the thread that we are waiting and
diff --git a/sysdeps/mach/hurd/htl/pt-sysdep.c b/sysdeps/mach/hurd/htl/pt-sysdep.c
index 270e7753..5372cbf7 100644
--- a/sysdeps/mach/hurd/htl/pt-sysdep.c
+++ b/sysdeps/mach/hurd/htl/pt-sysdep.c
@@ -100,7 +100,16 @@ _init_routine (void *stack)
      to the new stack.  Pretend it wasn't allocated so that it remains
      valid if the main thread terminates.  */
   thread->stack = 0;
+#if TLS_TCB_AT_TP
   thread->tcb = THREAD_SELF;
+#elif TLS_DTV_AT_TP
+  /* Assuming THREAD_SELF is implemented as subtracting TLS_PRE_TCB_SIZE
+     from the value of a thread pointer regsiter, this should optimize
+     down to simply reading that register.  */
+  thread->tcb = (tcbhead_t *) (((char *) THREAD_SELF) + TLS_PRE_TCB_SIZE);
+#else
+# error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
+#endif
 
 #ifndef PAGESIZE
   __pthread_default_attr.__guardsize = __vm_page_size;
-- 
2.44.0

[PATCH v2 19/20] htl: Add an AArch64 implementation

[Sergey Bugaev]

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---
 sysdeps/aarch64/htl/Makefile                 | 20 ++++++
 sysdeps/aarch64/htl/bits/pthreadtypes-arch.h | 36 ++++++++++
 sysdeps/aarch64/htl/machine-sp.h             | 29 ++++++++
 sysdeps/aarch64/htl/pt-machdep.h             | 28 ++++++++
 sysdeps/mach/hurd/aarch64/htl/pt-machdep.c   | 55 ++++++++++++++
 sysdeps/mach/hurd/aarch64/htl/pt-setup.c     | 76 ++++++++++++++++++++
 6 files changed, 244 insertions(+)
 create mode 100644 sysdeps/aarch64/htl/Makefile
 create mode 100644 sysdeps/aarch64/htl/bits/pthreadtypes-arch.h
 create mode 100644 sysdeps/aarch64/htl/machine-sp.h
 create mode 100644 sysdeps/aarch64/htl/pt-machdep.h
 create mode 100644 sysdeps/mach/hurd/aarch64/htl/pt-machdep.c
 create mode 100644 sysdeps/mach/hurd/aarch64/htl/pt-setup.c

diff --git a/sysdeps/aarch64/htl/Makefile b/sysdeps/aarch64/htl/Makefile
new file mode 100644
index 00000000..686b843d
--- /dev/null
+++ b/sysdeps/aarch64/htl/Makefile
@@ -0,0 +1,20 @@
+# Copyright (C) 2020-2024 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/>.
+
+ifeq ($(subdir),csu)
+gen-as-const-headers += tcb-offsets.sym
+endif
diff --git a/sysdeps/aarch64/htl/bits/pthreadtypes-arch.h b/sysdeps/aarch64/htl/bits/pthreadtypes-arch.h
new file mode 100644
index 00000000..9ee1568e
--- /dev/null
+++ b/sysdeps/aarch64/htl/bits/pthreadtypes-arch.h
@@ -0,0 +1,36 @@
+/* Machine-specific pthread type layouts.  Hurd AArch64 version.
+   Copyright (C) 2002-2024 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/>.  */
+
+#ifndef _BITS_PTHREADTYPES_ARCH_H
+#define _BITS_PTHREADTYPES_ARCH_H	1
+
+#define __SIZEOF_PTHREAD_MUTEX_T 32
+#define __SIZEOF_PTHREAD_ATTR_T 48
+#define __SIZEOF_PTHREAD_RWLOCK_T 48
+#define __SIZEOF_PTHREAD_BARRIER_T 40
+#define __SIZEOF_PTHREAD_MUTEXATTR_T 16
+#define __SIZEOF_PTHREAD_COND_T 40
+#define __SIZEOF_PTHREAD_CONDATTR_T 8
+#define __SIZEOF_PTHREAD_RWLOCKATTR_T 4
+#define __SIZEOF_PTHREAD_BARRIERATTR_T 4
+#define __SIZEOF_PTHREAD_ONCE_T 8
+
+#define __LOCK_ALIGNMENT
+#define __ONCE_ALIGNMENT
+
+#endif /* bits/pthreadtypes.h */
diff --git a/sysdeps/aarch64/htl/machine-sp.h b/sysdeps/aarch64/htl/machine-sp.h
new file mode 100644
index 00000000..b21331a0
--- /dev/null
+++ b/sysdeps/aarch64/htl/machine-sp.h
@@ -0,0 +1,29 @@
+/* Machine-specific function to return the stack pointer.  AArch64 version.
+   Copyright (C) 1994-2024 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/>.  */
+
+#ifndef _MACHINE_SP_H
+#define _MACHINE_SP_H
+
+/* Return the current stack pointer.  */
+
+#define __thread_stack_pointer() ({						\
+  register uintptr_t __sp__ asm("sp");						\
+  __sp__;									\
+})
+
+#endif /* machine-sp.h */
diff --git a/sysdeps/aarch64/htl/pt-machdep.h b/sysdeps/aarch64/htl/pt-machdep.h
new file mode 100644
index 00000000..c3681b4a
--- /dev/null
+++ b/sysdeps/aarch64/htl/pt-machdep.h
@@ -0,0 +1,28 @@
+/* Machine dependent pthreads internal definitions.  AArch64 version.
+   Copyright (C) 2000-2024 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/>.  */
+
+#ifndef _PT_MACHDEP_H
+#define _PT_MACHDEP_H	1
+
+struct pthread_mcontext
+{
+  void *pc;
+  void *sp;
+};
+
+#endif /* pt-machdep.h */
diff --git a/sysdeps/mach/hurd/aarch64/htl/pt-machdep.c b/sysdeps/mach/hurd/aarch64/htl/pt-machdep.c
new file mode 100644
index 00000000..e6e68ee1
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/htl/pt-machdep.c
@@ -0,0 +1,55 @@
+/* Machine dependent pthreads code.  Hurd/AArch64 version.
+   Copyright (C) 2000-2024 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 <assert.h>
+
+#include <mach.h>
+#include <mach/machine/thread_status.h>
+#include <mach/mig_errors.h>
+#include <mach/thread_status.h>
+
+int
+__thread_set_pcsptp (thread_t thread,
+                     int set_pc, void *pc,
+                     int set_sp, void *sp,
+                     int set_tp, void *tp)
+{
+  error_t err;
+  struct aarch64_thread_state state;
+  mach_msg_type_number_t state_count;
+
+  state_count = AARCH64_THREAD_STATE_COUNT;
+
+  err = __thread_get_state (thread, AARCH64_THREAD_STATE,
+                            (thread_state_t) &state, &state_count);
+  if (err)
+    return err;
+  assert (state_count == AARCH64_THREAD_STATE_COUNT);
+
+  if (set_pc)
+    state.pc = (uintptr_t) pc;
+  if (set_sp)
+    state.sp = (uintptr_t) sp;
+  if (set_tp)
+    state.tpidr_el0 = (uintptr_t) tp;
+
+  return __thread_set_state (thread, AARCH64_THREAD_STATE,
+			     (thread_state_t) &state,
+			     AARCH64_THREAD_STATE_COUNT);
+}
diff --git a/sysdeps/mach/hurd/aarch64/htl/pt-setup.c b/sysdeps/mach/hurd/aarch64/htl/pt-setup.c
new file mode 100644
index 00000000..e57d9210
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/htl/pt-setup.c
@@ -0,0 +1,76 @@
+/* Setup thread stack.  Hurd/AArch64 version.
+   Copyright (C) 2000-2024 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 <stdint.h>
+#include <assert.h>
+#include <mach.h>
+#include <hurd.h>
+
+#include <thread_state.h>
+#include <pt-internal.h>
+
+/* Set up the stack for THREAD.  Return the stack pointer
+   for the new thread.  */
+static void *
+stack_setup (struct __pthread *thread)
+{
+  error_t err;
+  uintptr_t bottom, top;
+
+  /* Calculate the top of the new stack.  */
+  bottom = (uintptr_t) thread->stackaddr;
+  top = bottom + thread->stacksize + round_page (thread->guardsize);
+
+  if (thread->guardsize)
+    {
+      err = __vm_protect (__mach_task_self (), (vm_address_t) bottom,
+			  thread->guardsize, 0, 0);
+      assert_perror (err);
+    }
+
+  return (void *) top;
+}
+
+int
+__pthread_setup (struct __pthread *thread,
+		 void (*entry_point) (struct __pthread *, void *(*)(void *),
+				      void *),
+		 void *(*start_routine) (void *),
+		 void *arg)
+{
+  struct aarch64_thread_state state;
+
+  if (thread->kernel_thread == __hurd_thread_self ())
+    return 0;
+
+  thread->mcontext.pc = entry_point;
+  thread->mcontext.sp = stack_setup (thread);
+
+  /* Set up the state to call entry_point (thread, start_routine, arg) */
+  memset (&state, 0, sizeof (state));
+  state.sp = (uintptr_t) thread->mcontext.sp;
+  state.pc = (uintptr_t) thread->mcontext.pc;
+  state.x[0] = (uintptr_t) thread;
+  state.x[1] = (uintptr_t) start_routine;
+  state.x[2] = (uintptr_t) arg;
+  state.tpidr_el0 = (uintptr_t) thread->tcb;
+
+  return __thread_set_state (thread->kernel_thread, AARCH64_THREAD_STATE,
+			     (thread_state_t) &state,
+			     AARCH64_THREAD_STATE_COUNT);
+}
-- 
2.44.0

[PATCH v2 20/20] hurd: Add expected aarch64-gnu abistlists

[Sergey Bugaev]

Signed-off-by: Sergey Bugaev <bugaevc@gmail.com>
---

We obviously didn't make it into the 2.39 timeframe, so now tentatively
targeting 2.40.

 sysdeps/mach/hurd/aarch64/ld.abilist          |   18 +
 .../mach/hurd/aarch64/libBrokenLocale.abilist |    1 +
 sysdeps/mach/hurd/aarch64/libanl.abilist      |    4 +
 sysdeps/mach/hurd/aarch64/libc.abilist        | 2193 +++++++++++++++++
 .../hurd/aarch64/libc_malloc_debug.abilist    |   26 +
 sysdeps/mach/hurd/aarch64/libdl.abilist       |    0
 sysdeps/mach/hurd/aarch64/libm.abilist        | 1030 ++++++++
 sysdeps/mach/hurd/aarch64/libmvec.abilist     |   75 +
 sysdeps/mach/hurd/aarch64/libpthread.abilist  |  165 ++
 sysdeps/mach/hurd/aarch64/libresolv.abilist   |   55 +
 sysdeps/mach/hurd/aarch64/librt.abilist       |   33 +
 11 files changed, 3600 insertions(+)
 create mode 100644 sysdeps/mach/hurd/aarch64/ld.abilist
 create mode 100644 sysdeps/mach/hurd/aarch64/libBrokenLocale.abilist
 create mode 100644 sysdeps/mach/hurd/aarch64/libanl.abilist
 create mode 100644 sysdeps/mach/hurd/aarch64/libc.abilist
 create mode 100644 sysdeps/mach/hurd/aarch64/libc_malloc_debug.abilist
 create mode 100644 sysdeps/mach/hurd/aarch64/libdl.abilist
 create mode 100644 sysdeps/mach/hurd/aarch64/libm.abilist
 create mode 100644 sysdeps/mach/hurd/aarch64/libmvec.abilist
 create mode 100644 sysdeps/mach/hurd/aarch64/libpthread.abilist
 create mode 100644 sysdeps/mach/hurd/aarch64/libresolv.abilist
 create mode 100644 sysdeps/mach/hurd/aarch64/librt.abilist

diff --git a/sysdeps/mach/hurd/aarch64/ld.abilist b/sysdeps/mach/hurd/aarch64/ld.abilist
new file mode 100644
index 00000000..ba01b289
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/ld.abilist
@@ -0,0 +1,18 @@
+GLIBC_2.40 __close F
+GLIBC_2.40 __errno_location F
+GLIBC_2.40 __getpid F
+GLIBC_2.40 __libc_stack_end D 0x8
+GLIBC_2.40 __mmap F
+GLIBC_2.40 __open F
+GLIBC_2.40 __open64 F
+GLIBC_2.40 __pread64 F
+GLIBC_2.40 __read F
+GLIBC_2.40 __sbrk F
+GLIBC_2.40 __stack_chk_guard D 0x8
+GLIBC_2.40 __tls_get_addr F
+GLIBC_2.40 __write F
+GLIBC_2.40 __writev F
+GLIBC_2.40 _dl_mcount F
+GLIBC_2.40 _hurd_intr_rpc_mach_msg F
+GLIBC_2.40 _r_debug D 0x28
+GLIBC_2.40 abort F
diff --git a/sysdeps/mach/hurd/aarch64/libBrokenLocale.abilist b/sysdeps/mach/hurd/aarch64/libBrokenLocale.abilist
new file mode 100644
index 00000000..f54dcd1b
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/libBrokenLocale.abilist
@@ -0,0 +1 @@
+GLIBC_2.40 __ctype_get_mb_cur_max F
diff --git a/sysdeps/mach/hurd/aarch64/libanl.abilist b/sysdeps/mach/hurd/aarch64/libanl.abilist
new file mode 100644
index 00000000..47ee5ca3
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/libanl.abilist
@@ -0,0 +1,4 @@
+GLIBC_2.40 gai_cancel F
+GLIBC_2.40 gai_error F
+GLIBC_2.40 gai_suspend F
+GLIBC_2.40 getaddrinfo_a F
diff --git a/sysdeps/mach/hurd/aarch64/libc.abilist b/sysdeps/mach/hurd/aarch64/libc.abilist
new file mode 100644
index 00000000..3e16e997
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/libc.abilist
@@ -0,0 +1,2193 @@
+GLIBC_2.40 _Exit F
+GLIBC_2.40 _Fork F
+GLIBC_2.40 _IO_2_1_stderr_ D 0xe0
+GLIBC_2.40 _IO_2_1_stdin_ D 0xe0
+GLIBC_2.40 _IO_2_1_stdout_ D 0xe0
+GLIBC_2.40 _IO_adjust_column F
+GLIBC_2.40 _IO_adjust_wcolumn F
+GLIBC_2.40 _IO_default_doallocate F
+GLIBC_2.40 _IO_default_finish F
+GLIBC_2.40 _IO_default_pbackfail F
+GLIBC_2.40 _IO_default_uflow F
+GLIBC_2.40 _IO_default_xsgetn F
+GLIBC_2.40 _IO_default_xsputn F
+GLIBC_2.40 _IO_do_write F
+GLIBC_2.40 _IO_doallocbuf F
+GLIBC_2.40 _IO_fclose F
+GLIBC_2.40 _IO_fdopen F
+GLIBC_2.40 _IO_feof F
+GLIBC_2.40 _IO_ferror F
+GLIBC_2.40 _IO_fflush F
+GLIBC_2.40 _IO_fgetpos F
+GLIBC_2.40 _IO_fgetpos64 F
+GLIBC_2.40 _IO_fgets F
+GLIBC_2.40 _IO_file_attach F
+GLIBC_2.40 _IO_file_close F
+GLIBC_2.40 _IO_file_close_it F
+GLIBC_2.40 _IO_file_doallocate F
+GLIBC_2.40 _IO_file_finish F
+GLIBC_2.40 _IO_file_fopen F
+GLIBC_2.40 _IO_file_init F
+GLIBC_2.40 _IO_file_jumps D 0xa8
+GLIBC_2.40 _IO_file_open F
+GLIBC_2.40 _IO_file_overflow F
+GLIBC_2.40 _IO_file_read F
+GLIBC_2.40 _IO_file_seek F
+GLIBC_2.40 _IO_file_seekoff F
+GLIBC_2.40 _IO_file_setbuf F
+GLIBC_2.40 _IO_file_stat F
+GLIBC_2.40 _IO_file_sync F
+GLIBC_2.40 _IO_file_underflow F
+GLIBC_2.40 _IO_file_write F
+GLIBC_2.40 _IO_file_xsputn F
+GLIBC_2.40 _IO_flockfile F
+GLIBC_2.40 _IO_flush_all F
+GLIBC_2.40 _IO_flush_all_linebuffered F
+GLIBC_2.40 _IO_fopen F
+GLIBC_2.40 _IO_fprintf F
+GLIBC_2.40 _IO_fputs F
+GLIBC_2.40 _IO_fread F
+GLIBC_2.40 _IO_free_backup_area F
+GLIBC_2.40 _IO_free_wbackup_area F
+GLIBC_2.40 _IO_fsetpos F
+GLIBC_2.40 _IO_fsetpos64 F
+GLIBC_2.40 _IO_ftell F
+GLIBC_2.40 _IO_ftrylockfile F
+GLIBC_2.40 _IO_funlockfile F
+GLIBC_2.40 _IO_fwrite F
+GLIBC_2.40 _IO_getc F
+GLIBC_2.40 _IO_getline F
+GLIBC_2.40 _IO_getline_info F
+GLIBC_2.40 _IO_gets F
+GLIBC_2.40 _IO_init F
+GLIBC_2.40 _IO_init_marker F
+GLIBC_2.40 _IO_init_wmarker F
+GLIBC_2.40 _IO_iter_begin F
+GLIBC_2.40 _IO_iter_end F
+GLIBC_2.40 _IO_iter_file F
+GLIBC_2.40 _IO_iter_next F
+GLIBC_2.40 _IO_least_wmarker F
+GLIBC_2.40 _IO_link_in F
+GLIBC_2.40 _IO_list_all D 0x8
+GLIBC_2.40 _IO_list_lock F
+GLIBC_2.40 _IO_list_resetlock F
+GLIBC_2.40 _IO_list_unlock F
+GLIBC_2.40 _IO_marker_delta F
+GLIBC_2.40 _IO_marker_difference F
+GLIBC_2.40 _IO_padn F
+GLIBC_2.40 _IO_peekc_locked F
+GLIBC_2.40 _IO_popen F
+GLIBC_2.40 _IO_printf F
+GLIBC_2.40 _IO_proc_close F
+GLIBC_2.40 _IO_proc_open F
+GLIBC_2.40 _IO_putc F
+GLIBC_2.40 _IO_puts F
+GLIBC_2.40 _IO_remove_marker F
+GLIBC_2.40 _IO_seekmark F
+GLIBC_2.40 _IO_seekoff F
+GLIBC_2.40 _IO_seekpos F
+GLIBC_2.40 _IO_seekwmark F
+GLIBC_2.40 _IO_setb F
+GLIBC_2.40 _IO_setbuffer F
+GLIBC_2.40 _IO_setvbuf F
+GLIBC_2.40 _IO_sgetn F
+GLIBC_2.40 _IO_sprintf F
+GLIBC_2.40 _IO_sputbackc F
+GLIBC_2.40 _IO_sputbackwc F
+GLIBC_2.40 _IO_sscanf F
+GLIBC_2.40 _IO_str_init_readonly F
+GLIBC_2.40 _IO_str_init_static F
+GLIBC_2.40 _IO_str_overflow F
+GLIBC_2.40 _IO_str_pbackfail F
+GLIBC_2.40 _IO_str_seekoff F
+GLIBC_2.40 _IO_str_underflow F
+GLIBC_2.40 _IO_sungetc F
+GLIBC_2.40 _IO_sungetwc F
+GLIBC_2.40 _IO_switch_to_get_mode F
+GLIBC_2.40 _IO_switch_to_main_wget_area F
+GLIBC_2.40 _IO_switch_to_wbackup_area F
+GLIBC_2.40 _IO_switch_to_wget_mode F
+GLIBC_2.40 _IO_un_link F
+GLIBC_2.40 _IO_ungetc F
+GLIBC_2.40 _IO_unsave_markers F
+GLIBC_2.40 _IO_unsave_wmarkers F
+GLIBC_2.40 _IO_vfprintf F
+GLIBC_2.40 _IO_vsprintf F
+GLIBC_2.40 _IO_wdefault_doallocate F
+GLIBC_2.40 _IO_wdefault_finish F
+GLIBC_2.40 _IO_wdefault_pbackfail F
+GLIBC_2.40 _IO_wdefault_uflow F
+GLIBC_2.40 _IO_wdefault_xsgetn F
+GLIBC_2.40 _IO_wdefault_xsputn F
+GLIBC_2.40 _IO_wdo_write F
+GLIBC_2.40 _IO_wdoallocbuf F
+GLIBC_2.40 _IO_wfile_jumps D 0xa8
+GLIBC_2.40 _IO_wfile_overflow F
+GLIBC_2.40 _IO_wfile_seekoff F
+GLIBC_2.40 _IO_wfile_sync F
+GLIBC_2.40 _IO_wfile_underflow F
+GLIBC_2.40 _IO_wfile_xsputn F
+GLIBC_2.40 _IO_wmarker_delta F
+GLIBC_2.40 _IO_wsetb F
+GLIBC_2.40 _S_catch_exception_raise F
+GLIBC_2.40 _S_msg_add_auth F
+GLIBC_2.40 _S_msg_del_auth F
+GLIBC_2.40 _S_msg_describe_ports F
+GLIBC_2.40 _S_msg_get_dtable F
+GLIBC_2.40 _S_msg_get_env_variable F
+GLIBC_2.40 _S_msg_get_environment F
+GLIBC_2.40 _S_msg_get_fd F
+GLIBC_2.40 _S_msg_get_init_int F
+GLIBC_2.40 _S_msg_get_init_ints F
+GLIBC_2.40 _S_msg_get_init_port F
+GLIBC_2.40 _S_msg_get_init_ports F
+GLIBC_2.40 _S_msg_proc_newids F
+GLIBC_2.40 _S_msg_report_wait F
+GLIBC_2.40 _S_msg_set_dtable F
+GLIBC_2.40 _S_msg_set_env_variable F
+GLIBC_2.40 _S_msg_set_environment F
+GLIBC_2.40 _S_msg_set_fd F
+GLIBC_2.40 _S_msg_set_init_int F
+GLIBC_2.40 _S_msg_set_init_ints F
+GLIBC_2.40 _S_msg_set_init_port F
+GLIBC_2.40 _S_msg_set_init_ports F
+GLIBC_2.40 _S_msg_sig_post F
+GLIBC_2.40 _S_msg_sig_post_untraced F
+GLIBC_2.40 ___brk_addr D 0x8
+GLIBC_2.40 __argz_count F
+GLIBC_2.40 __argz_next F
+GLIBC_2.40 __argz_stringify F
+GLIBC_2.40 __asprintf F
+GLIBC_2.40 __asprintf_chk F
+GLIBC_2.40 __assert F
+GLIBC_2.40 __assert_fail F
+GLIBC_2.40 __assert_perror_fail F
+GLIBC_2.40 __backtrace F
+GLIBC_2.40 __backtrace_symbols F
+GLIBC_2.40 __backtrace_symbols_fd F
+GLIBC_2.40 __bsd_getpgrp F
+GLIBC_2.40 __bzero F
+GLIBC_2.40 __check_rhosts_file D 0x4
+GLIBC_2.40 __chk_fail F
+GLIBC_2.40 __close F
+GLIBC_2.40 __cmsg_nxthdr F
+GLIBC_2.40 __confstr_chk F
+GLIBC_2.40 __connect F
+GLIBC_2.40 __ctype_b_loc F
+GLIBC_2.40 __ctype_get_mb_cur_max F
+GLIBC_2.40 __ctype_tolower_loc F
+GLIBC_2.40 __ctype_toupper_loc F
+GLIBC_2.40 __cxa_at_quick_exit F
+GLIBC_2.40 __cxa_atexit F
+GLIBC_2.40 __cxa_finalize F
+GLIBC_2.40 __cxa_thread_atexit_impl F
+GLIBC_2.40 __cyg_profile_func_enter F
+GLIBC_2.40 __cyg_profile_func_exit F
+GLIBC_2.40 __daylight D 0x4
+GLIBC_2.40 __dcgettext F
+GLIBC_2.40 __dgettext F
+GLIBC_2.40 __dprintf_chk F
+GLIBC_2.40 __dup2 F
+GLIBC_2.40 __duplocale F
+GLIBC_2.40 __environ D 0x8
+GLIBC_2.40 __errno_location F
+GLIBC_2.40 __explicit_bzero_chk F
+GLIBC_2.40 __fbufsize F
+GLIBC_2.40 __fcntl F
+GLIBC_2.40 __fdelt_chk F
+GLIBC_2.40 __fdelt_warn F
+GLIBC_2.40 __ffs F
+GLIBC_2.40 __fgets_chk F
+GLIBC_2.40 __fgets_unlocked_chk F
+GLIBC_2.40 __fgetws_chk F
+GLIBC_2.40 __fgetws_unlocked_chk F
+GLIBC_2.40 __finite F
+GLIBC_2.40 __finitef F
+GLIBC_2.40 __finitel F
+GLIBC_2.40 __flbf F
+GLIBC_2.40 __fork F
+GLIBC_2.40 __fpending F
+GLIBC_2.40 __fprintf_chk F
+GLIBC_2.40 __fpu_control D 0x4
+GLIBC_2.40 __fpurge F
+GLIBC_2.40 __fread_chk F
+GLIBC_2.40 __fread_unlocked_chk F
+GLIBC_2.40 __freadable F
+GLIBC_2.40 __freading F
+GLIBC_2.40 __freelocale F
+GLIBC_2.40 __fsetlocking F
+GLIBC_2.40 __fwprintf_chk F
+GLIBC_2.40 __fwritable F
+GLIBC_2.40 __fwriting F
+GLIBC_2.40 __getauxval F
+GLIBC_2.40 __getcwd_chk F
+GLIBC_2.40 __getdelim F
+GLIBC_2.40 __getdomainname_chk F
+GLIBC_2.40 __getgroups_chk F
+GLIBC_2.40 __gethostname_chk F
+GLIBC_2.40 __getlogin_r_chk F
+GLIBC_2.40 __getpagesize F
+GLIBC_2.40 __getpgid F
+GLIBC_2.40 __getpid F
+GLIBC_2.40 __gets_chk F
+GLIBC_2.40 __gettimeofday F
+GLIBC_2.40 __getwd_chk F
+GLIBC_2.40 __gmtime_r F
+GLIBC_2.40 __h_errno_location F
+GLIBC_2.40 __hurd_dfail F
+GLIBC_2.40 __hurd_fail F
+GLIBC_2.40 __hurd_sockfail F
+GLIBC_2.40 __isalnum_l F
+GLIBC_2.40 __isalpha_l F
+GLIBC_2.40 __isascii_l F
+GLIBC_2.40 __isblank_l F
+GLIBC_2.40 __iscntrl_l F
+GLIBC_2.40 __isctype F
+GLIBC_2.40 __isdigit_l F
+GLIBC_2.40 __isgraph_l F
+GLIBC_2.40 __isinf F
+GLIBC_2.40 __isinff F
+GLIBC_2.40 __isinfl F
+GLIBC_2.40 __islower_l F
+GLIBC_2.40 __isnan F
+GLIBC_2.40 __isnanf F
+GLIBC_2.40 __isnanl F
+GLIBC_2.40 __isoc23_fscanf F
+GLIBC_2.40 __isoc23_fwscanf F
+GLIBC_2.40 __isoc23_scanf F
+GLIBC_2.40 __isoc23_sscanf F
+GLIBC_2.40 __isoc23_strtoimax F
+GLIBC_2.40 __isoc23_strtol F
+GLIBC_2.40 __isoc23_strtol_l F
+GLIBC_2.40 __isoc23_strtoll F
+GLIBC_2.40 __isoc23_strtoll_l F
+GLIBC_2.40 __isoc23_strtoul F
+GLIBC_2.40 __isoc23_strtoul_l F
+GLIBC_2.40 __isoc23_strtoull F
+GLIBC_2.40 __isoc23_strtoull_l F
+GLIBC_2.40 __isoc23_strtoumax F
+GLIBC_2.40 __isoc23_swscanf F
+GLIBC_2.40 __isoc23_vfscanf F
+GLIBC_2.40 __isoc23_vfwscanf F
+GLIBC_2.40 __isoc23_vscanf F
+GLIBC_2.40 __isoc23_vsscanf F
+GLIBC_2.40 __isoc23_vswscanf F
+GLIBC_2.40 __isoc23_vwscanf F
+GLIBC_2.40 __isoc23_wcstoimax F
+GLIBC_2.40 __isoc23_wcstol F
+GLIBC_2.40 __isoc23_wcstol_l F
+GLIBC_2.40 __isoc23_wcstoll F
+GLIBC_2.40 __isoc23_wcstoll_l F
+GLIBC_2.40 __isoc23_wcstoul F
+GLIBC_2.40 __isoc23_wcstoul_l F
+GLIBC_2.40 __isoc23_wcstoull F
+GLIBC_2.40 __isoc23_wcstoull_l F
+GLIBC_2.40 __isoc23_wcstoumax F
+GLIBC_2.40 __isoc23_wscanf F
+GLIBC_2.40 __isoc99_fscanf F
+GLIBC_2.40 __isoc99_fwscanf F
+GLIBC_2.40 __isoc99_scanf F
+GLIBC_2.40 __isoc99_sscanf F
+GLIBC_2.40 __isoc99_swscanf F
+GLIBC_2.40 __isoc99_vfscanf F
+GLIBC_2.40 __isoc99_vfwscanf F
+GLIBC_2.40 __isoc99_vscanf F
+GLIBC_2.40 __isoc99_vsscanf F
+GLIBC_2.40 __isoc99_vswscanf F
+GLIBC_2.40 __isoc99_vwscanf F
+GLIBC_2.40 __isoc99_wscanf F
+GLIBC_2.40 __isprint_l F
+GLIBC_2.40 __ispunct_l F
+GLIBC_2.40 __isspace_l F
+GLIBC_2.40 __isupper_l F
+GLIBC_2.40 __iswalnum_l F
+GLIBC_2.40 __iswalpha_l F
+GLIBC_2.40 __iswblank_l F
+GLIBC_2.40 __iswcntrl_l F
+GLIBC_2.40 __iswctype F
+GLIBC_2.40 __iswctype_l F
+GLIBC_2.40 __iswdigit_l F
+GLIBC_2.40 __iswgraph_l F
+GLIBC_2.40 __iswlower_l F
+GLIBC_2.40 __iswprint_l F
+GLIBC_2.40 __iswpunct_l F
+GLIBC_2.40 __iswspace_l F
+GLIBC_2.40 __iswupper_l F
+GLIBC_2.40 __iswxdigit_l F
+GLIBC_2.40 __isxdigit_l F
+GLIBC_2.40 __libc_allocate_rtsig F
+GLIBC_2.40 __libc_calloc F
+GLIBC_2.40 __libc_current_sigrtmax F
+GLIBC_2.40 __libc_current_sigrtmin F
+GLIBC_2.40 __libc_free F
+GLIBC_2.40 __libc_freeres F
+GLIBC_2.40 __libc_init_first F
+GLIBC_2.40 __libc_mallinfo F
+GLIBC_2.40 __libc_malloc F
+GLIBC_2.40 __libc_mallopt F
+GLIBC_2.40 __libc_memalign F
+GLIBC_2.40 __libc_pvalloc F
+GLIBC_2.40 __libc_realloc F
+GLIBC_2.40 __libc_single_threaded D 0x1
+GLIBC_2.40 __libc_start_main F
+GLIBC_2.40 __libc_valloc F
+GLIBC_2.40 __longjmp_chk F
+GLIBC_2.40 __lseek F
+GLIBC_2.40 __mach_host_self_ D 0x4
+GLIBC_2.40 __mach_msg F
+GLIBC_2.40 __mach_msg_destroy F
+GLIBC_2.40 __mach_port_allocate F
+GLIBC_2.40 __mach_port_deallocate F
+GLIBC_2.40 __mach_port_insert_right F
+GLIBC_2.40 __mach_reply_port F
+GLIBC_2.40 __mach_task_self_ D 0x4
+GLIBC_2.40 __mach_thread_self F
+GLIBC_2.40 __mbrlen F
+GLIBC_2.40 __mbrtowc F
+GLIBC_2.40 __mbsnrtowcs_chk F
+GLIBC_2.40 __mbsrtowcs_chk F
+GLIBC_2.40 __mbstowcs_chk F
+GLIBC_2.40 __memcmpeq F
+GLIBC_2.40 __memcpy_chk F
+GLIBC_2.40 __memmove_chk F
+GLIBC_2.40 __mempcpy F
+GLIBC_2.40 __mempcpy_chk F
+GLIBC_2.40 __memset_chk F
+GLIBC_2.40 __mig_allocate F
+GLIBC_2.40 __mig_dealloc_reply_port F
+GLIBC_2.40 __mig_deallocate F
+GLIBC_2.40 __mig_get_reply_port F
+GLIBC_2.40 __mig_init F
+GLIBC_2.40 __mig_put_reply_port F
+GLIBC_2.40 __mig_strncpy F
+GLIBC_2.40 __mmap F
+GLIBC_2.40 __monstartup F
+GLIBC_2.40 __nanosleep F
+GLIBC_2.40 __newlocale F
+GLIBC_2.40 __nl_langinfo_l F
+GLIBC_2.40 __nss_configure_lookup F
+GLIBC_2.40 __nss_hostname_digits_dots F
+GLIBC_2.40 __obstack_printf_chk F
+GLIBC_2.40 __obstack_vprintf_chk F
+GLIBC_2.40 __open F
+GLIBC_2.40 __open64 F
+GLIBC_2.40 __open64_2 F
+GLIBC_2.40 __open_2 F
+GLIBC_2.40 __openat64_2 F
+GLIBC_2.40 __openat_2 F
+GLIBC_2.40 __overflow F
+GLIBC_2.40 __pipe F
+GLIBC_2.40 __poll F
+GLIBC_2.40 __poll_chk F
+GLIBC_2.40 __posix_getopt F
+GLIBC_2.40 __ppoll_chk F
+GLIBC_2.40 __pread64 F
+GLIBC_2.40 __pread64_chk F
+GLIBC_2.40 __pread_chk F
+GLIBC_2.40 __printf_chk F
+GLIBC_2.40 __printf_fp F
+GLIBC_2.40 __profile_frequency F
+GLIBC_2.40 __progname D 0x8
+GLIBC_2.40 __progname_full D 0x8
+GLIBC_2.40 __pthread_get_cleanup_stack F
+GLIBC_2.40 __pthread_self F
+GLIBC_2.40 __ptsname_r_chk F
+GLIBC_2.40 __pwrite64 F
+GLIBC_2.40 __rawmemchr F
+GLIBC_2.40 __rcmd_errstr D 0x8
+GLIBC_2.40 __read F
+GLIBC_2.40 __read_chk F
+GLIBC_2.40 __readlink_chk F
+GLIBC_2.40 __readlinkat_chk F
+GLIBC_2.40 __realpath_chk F
+GLIBC_2.40 __recv_chk F
+GLIBC_2.40 __recvfrom_chk F
+GLIBC_2.40 __register_atfork F
+GLIBC_2.40 __res_init F
+GLIBC_2.40 __res_nclose F
+GLIBC_2.40 __res_ninit F
+GLIBC_2.40 __res_randomid F
+GLIBC_2.40 __res_state F
+GLIBC_2.40 __sbrk F
+GLIBC_2.40 __sched_cpualloc F
+GLIBC_2.40 __sched_cpucount F
+GLIBC_2.40 __sched_cpufree F
+GLIBC_2.40 __sched_get_priority_max F
+GLIBC_2.40 __sched_get_priority_min F
+GLIBC_2.40 __sched_getparam F
+GLIBC_2.40 __sched_getscheduler F
+GLIBC_2.40 __sched_setscheduler F
+GLIBC_2.40 __sched_yield F
+GLIBC_2.40 __select F
+GLIBC_2.40 __send F
+GLIBC_2.40 __setpgid F
+GLIBC_2.40 __sigaction F
+GLIBC_2.40 __signbit F
+GLIBC_2.40 __signbitf F
+GLIBC_2.40 __signbitl F
+GLIBC_2.40 __sigpause F
+GLIBC_2.40 __sigsetjmp F
+GLIBC_2.40 __sigsuspend F
+GLIBC_2.40 __snprintf_chk F
+GLIBC_2.40 __sprintf_chk F
+GLIBC_2.40 __stack_chk_fail F
+GLIBC_2.40 __stpcpy F
+GLIBC_2.40 __stpcpy_chk F
+GLIBC_2.40 __stpncpy F
+GLIBC_2.40 __stpncpy_chk F
+GLIBC_2.40 __strcasecmp F
+GLIBC_2.40 __strcasecmp_l F
+GLIBC_2.40 __strcasestr F
+GLIBC_2.40 __strcat_chk F
+GLIBC_2.40 __strcoll_l F
+GLIBC_2.40 __strcpy_chk F
+GLIBC_2.40 __strdup F
+GLIBC_2.40 __strerror_r F
+GLIBC_2.40 __strfmon_l F
+GLIBC_2.40 __strftime_l F
+GLIBC_2.40 __strlcat_chk F
+GLIBC_2.40 __strlcpy_chk F
+GLIBC_2.40 __strncasecmp_l F
+GLIBC_2.40 __strncat_chk F
+GLIBC_2.40 __strncpy_chk F
+GLIBC_2.40 __strndup F
+GLIBC_2.40 __strsep_g F
+GLIBC_2.40 __strtod_internal F
+GLIBC_2.40 __strtod_l F
+GLIBC_2.40 __strtof_internal F
+GLIBC_2.40 __strtof_l F
+GLIBC_2.40 __strtok_r F
+GLIBC_2.40 __strtol_internal F
+GLIBC_2.40 __strtol_l F
+GLIBC_2.40 __strtold_internal F
+GLIBC_2.40 __strtold_l F
+GLIBC_2.40 __strtoll_internal F
+GLIBC_2.40 __strtoll_l F
+GLIBC_2.40 __strtoul_internal F
+GLIBC_2.40 __strtoul_l F
+GLIBC_2.40 __strtoull_internal F
+GLIBC_2.40 __strtoull_l F
+GLIBC_2.40 __strverscmp F
+GLIBC_2.40 __strxfrm_l F
+GLIBC_2.40 __swprintf_chk F
+GLIBC_2.40 __sysconf F
+GLIBC_2.40 __syslog_chk F
+GLIBC_2.40 __sysv_signal F
+GLIBC_2.40 __timezone D 0x8
+GLIBC_2.40 __toascii_l F
+GLIBC_2.40 __tolower_l F
+GLIBC_2.40 __toupper_l F
+GLIBC_2.40 __towctrans F
+GLIBC_2.40 __towctrans_l F
+GLIBC_2.40 __towlower_l F
+GLIBC_2.40 __towupper_l F
+GLIBC_2.40 __ttyname_r_chk F
+GLIBC_2.40 __tzname D 0x10
+GLIBC_2.40 __uflow F
+GLIBC_2.40 __underflow F
+GLIBC_2.40 __uselocale F
+GLIBC_2.40 __vasprintf_chk F
+GLIBC_2.40 __vdprintf_chk F
+GLIBC_2.40 __vfork F
+GLIBC_2.40 __vfprintf_chk F
+GLIBC_2.40 __vfscanf F
+GLIBC_2.40 __vfwprintf_chk F
+GLIBC_2.40 __vm_allocate F
+GLIBC_2.40 __vm_deallocate F
+GLIBC_2.40 __vm_page_size D 0x8
+GLIBC_2.40 __vprintf_chk F
+GLIBC_2.40 __vsnprintf F
+GLIBC_2.40 __vsnprintf_chk F
+GLIBC_2.40 __vsprintf_chk F
+GLIBC_2.40 __vsscanf F
+GLIBC_2.40 __vswprintf_chk F
+GLIBC_2.40 __vsyslog_chk F
+GLIBC_2.40 __vwprintf_chk F
+GLIBC_2.40 __wait F
+GLIBC_2.40 __waitpid F
+GLIBC_2.40 __wcpcpy_chk F
+GLIBC_2.40 __wcpncpy_chk F
+GLIBC_2.40 __wcrtomb_chk F
+GLIBC_2.40 __wcscasecmp_l F
+GLIBC_2.40 __wcscat_chk F
+GLIBC_2.40 __wcscoll_l F
+GLIBC_2.40 __wcscpy_chk F
+GLIBC_2.40 __wcsftime_l F
+GLIBC_2.40 __wcslcat_chk F
+GLIBC_2.40 __wcslcpy_chk F
+GLIBC_2.40 __wcsncasecmp_l F
+GLIBC_2.40 __wcsncat_chk F
+GLIBC_2.40 __wcsncpy_chk F
+GLIBC_2.40 __wcsnrtombs_chk F
+GLIBC_2.40 __wcsrtombs_chk F
+GLIBC_2.40 __wcstod_internal F
+GLIBC_2.40 __wcstod_l F
+GLIBC_2.40 __wcstof_internal F
+GLIBC_2.40 __wcstof_l F
+GLIBC_2.40 __wcstol_internal F
+GLIBC_2.40 __wcstol_l F
+GLIBC_2.40 __wcstold_internal F
+GLIBC_2.40 __wcstold_l F
+GLIBC_2.40 __wcstoll_internal F
+GLIBC_2.40 __wcstoll_l F
+GLIBC_2.40 __wcstombs_chk F
+GLIBC_2.40 __wcstoul_internal F
+GLIBC_2.40 __wcstoul_l F
+GLIBC_2.40 __wcstoull_internal F
+GLIBC_2.40 __wcstoull_l F
+GLIBC_2.40 __wcsxfrm_l F
+GLIBC_2.40 __wctomb_chk F
+GLIBC_2.40 __wctrans_l F
+GLIBC_2.40 __wctype_l F
+GLIBC_2.40 __wmemcpy_chk F
+GLIBC_2.40 __wmemmove_chk F
+GLIBC_2.40 __wmempcpy_chk F
+GLIBC_2.40 __wmemset_chk F
+GLIBC_2.40 __woverflow F
+GLIBC_2.40 __wprintf_chk F
+GLIBC_2.40 __write F
+GLIBC_2.40 __writev F
+GLIBC_2.40 __wuflow F
+GLIBC_2.40 __wunderflow F
+GLIBC_2.40 __xpg_basename F
+GLIBC_2.40 __xpg_sigpause F
+GLIBC_2.40 __xpg_strerror_r F
+GLIBC_2.40 _dl_find_object F
+GLIBC_2.40 _dl_mcount_wrapper F
+GLIBC_2.40 _dl_mcount_wrapper_check F
+GLIBC_2.40 _environ D 0x8
+GLIBC_2.40 _exit F
+GLIBC_2.40 _flushlbf F
+GLIBC_2.40 _hurd_canonicalize_directory_name_internal F
+GLIBC_2.40 _hurd_critical_section_lock F
+GLIBC_2.40 _hurd_critical_section_unlock F
+GLIBC_2.40 _hurd_device_master D 0x4
+GLIBC_2.40 _hurd_dtable D 0x8
+GLIBC_2.40 _hurd_dtable_lock D 0x28
+GLIBC_2.40 _hurd_dtablesize D 0x4
+GLIBC_2.40 _hurd_exception2signal F
+GLIBC_2.40 _hurd_exec F
+GLIBC_2.40 _hurd_exec_paths F
+GLIBC_2.40 _hurd_fd_error F
+GLIBC_2.40 _hurd_fd_error_signal F
+GLIBC_2.40 _hurd_fd_get F
+GLIBC_2.40 _hurd_host_priv D 0x4
+GLIBC_2.40 _hurd_init F
+GLIBC_2.40 _hurd_intern_fd F
+GLIBC_2.40 _hurd_intr_rpc_mach_msg F
+GLIBC_2.40 _hurd_libc_proc_init F
+GLIBC_2.40 _hurd_msgport D 0x4
+GLIBC_2.40 _hurd_port_cleanup F
+GLIBC_2.40 _hurd_port_free F
+GLIBC_2.40 _hurd_port_get F
+GLIBC_2.40 _hurd_port_init F
+GLIBC_2.40 _hurd_port_locked_get F
+GLIBC_2.40 _hurd_port_locked_set F
+GLIBC_2.40 _hurd_port_move F
+GLIBC_2.40 _hurd_port_set F
+GLIBC_2.40 _hurd_ports D 0x8
+GLIBC_2.40 _hurd_ports_use F
+GLIBC_2.40 _hurd_proc_init F
+GLIBC_2.40 _hurd_raise_signal F
+GLIBC_2.40 _hurd_self_sigstate F
+GLIBC_2.40 _hurd_thread_sigstate F
+GLIBC_2.40 _hurd_userlink_clear F
+GLIBC_2.40 _hurd_userlink_link F
+GLIBC_2.40 _hurd_userlink_unlink F
+GLIBC_2.40 _hurdsig_fault_catch_exception_raise F
+GLIBC_2.40 _hurdsig_fault_env D 0xc0
+GLIBC_2.40 _hurdsig_fault_preemptor D 0x30
+GLIBC_2.40 _hurdsig_interrupt_timeout D 0x4
+GLIBC_2.40 _libc_intl_domainname D 0x5
+GLIBC_2.40 _longjmp F
+GLIBC_2.40 _mcleanup F
+GLIBC_2.40 _mcount F
+GLIBC_2.40 _nl_default_dirname D 0xe
+GLIBC_2.40 _nl_domain_bindings D 0x8
+GLIBC_2.40 _nl_msg_cat_cntr D 0x4
+GLIBC_2.40 _obstack_allocated_p F
+GLIBC_2.40 _obstack_begin F
+GLIBC_2.40 _obstack_begin_1 F
+GLIBC_2.40 _obstack_free F
+GLIBC_2.40 _obstack_memory_used F
+GLIBC_2.40 _obstack_newchunk F
+GLIBC_2.40 _res D 0x238
+GLIBC_2.40 _res_hconf D 0x48
+GLIBC_2.40 _setjmp F
+GLIBC_2.40 _tolower F
+GLIBC_2.40 _toupper F
+GLIBC_2.40 a64l F
+GLIBC_2.40 abort F
+GLIBC_2.40 abs F
+GLIBC_2.40 accept F
+GLIBC_2.40 accept4 F
+GLIBC_2.40 access F
+GLIBC_2.40 acct F
+GLIBC_2.40 addmntent F
+GLIBC_2.40 addseverity F
+GLIBC_2.40 adjtime F
+GLIBC_2.40 alarm F
+GLIBC_2.40 aligned_alloc F
+GLIBC_2.40 alphasort F
+GLIBC_2.40 alphasort64 F
+GLIBC_2.40 arc4random F
+GLIBC_2.40 arc4random_buf F
+GLIBC_2.40 arc4random_uniform F
+GLIBC_2.40 argp_err_exit_status D 0x4
+GLIBC_2.40 argp_error F
+GLIBC_2.40 argp_failure F
+GLIBC_2.40 argp_help F
+GLIBC_2.40 argp_parse F
+GLIBC_2.40 argp_program_bug_address D 0x8
+GLIBC_2.40 argp_program_version D 0x8
+GLIBC_2.40 argp_program_version_hook D 0x8
+GLIBC_2.40 argp_state_help F
+GLIBC_2.40 argp_usage F
+GLIBC_2.40 argz_add F
+GLIBC_2.40 argz_add_sep F
+GLIBC_2.40 argz_append F
+GLIBC_2.40 argz_count F
+GLIBC_2.40 argz_create F
+GLIBC_2.40 argz_create_sep F
+GLIBC_2.40 argz_delete F
+GLIBC_2.40 argz_extract F
+GLIBC_2.40 argz_insert F
+GLIBC_2.40 argz_next F
+GLIBC_2.40 argz_replace F
+GLIBC_2.40 argz_stringify F
+GLIBC_2.40 asctime F
+GLIBC_2.40 asctime_r F
+GLIBC_2.40 asprintf F
+GLIBC_2.40 atof F
+GLIBC_2.40 atoi F
+GLIBC_2.40 atol F
+GLIBC_2.40 atoll F
+GLIBC_2.40 backtrace F
+GLIBC_2.40 backtrace_symbols F
+GLIBC_2.40 backtrace_symbols_fd F
+GLIBC_2.40 basename F
+GLIBC_2.40 bcmp F
+GLIBC_2.40 bcopy F
+GLIBC_2.40 bind F
+GLIBC_2.40 bind_textdomain_codeset F
+GLIBC_2.40 bindresvport F
+GLIBC_2.40 bindtextdomain F
+GLIBC_2.40 brk F
+GLIBC_2.40 bsd_signal F
+GLIBC_2.40 bsearch F
+GLIBC_2.40 btowc F
+GLIBC_2.40 bzero F
+GLIBC_2.40 c16rtomb F
+GLIBC_2.40 c32rtomb F
+GLIBC_2.40 c8rtomb F
+GLIBC_2.40 calloc F
+GLIBC_2.40 canonicalize_file_name F
+GLIBC_2.40 catclose F
+GLIBC_2.40 catgets F
+GLIBC_2.40 catopen F
+GLIBC_2.40 cfgetispeed F
+GLIBC_2.40 cfgetospeed F
+GLIBC_2.40 cfmakeraw F
+GLIBC_2.40 cfsetispeed F
+GLIBC_2.40 cfsetospeed F
+GLIBC_2.40 cfsetspeed F
+GLIBC_2.40 chdir F
+GLIBC_2.40 chflags F
+GLIBC_2.40 chmod F
+GLIBC_2.40 chown F
+GLIBC_2.40 chroot F
+GLIBC_2.40 clearenv F
+GLIBC_2.40 clearerr F
+GLIBC_2.40 clearerr_unlocked F
+GLIBC_2.40 clock F
+GLIBC_2.40 clock_getcpuclockid F
+GLIBC_2.40 clock_getres F
+GLIBC_2.40 clock_gettime F
+GLIBC_2.40 clock_nanosleep F
+GLIBC_2.40 clock_settime F
+GLIBC_2.40 close F
+GLIBC_2.40 close_range F
+GLIBC_2.40 closedir F
+GLIBC_2.40 closefrom F
+GLIBC_2.40 closelog F
+GLIBC_2.40 confstr F
+GLIBC_2.40 connect F
+GLIBC_2.40 copy_file_range F
+GLIBC_2.40 copysign F
+GLIBC_2.40 copysignf F
+GLIBC_2.40 copysignl F
+GLIBC_2.40 creat F
+GLIBC_2.40 creat64 F
+GLIBC_2.40 ctermid F
+GLIBC_2.40 ctime F
+GLIBC_2.40 ctime_r F
+GLIBC_2.40 cuserid F
+GLIBC_2.40 daemon F
+GLIBC_2.40 daylight D 0x4
+GLIBC_2.40 dcgettext F
+GLIBC_2.40 dcngettext F
+GLIBC_2.40 dgettext F
+GLIBC_2.40 difftime F
+GLIBC_2.40 directory_name_split F
+GLIBC_2.40 dirfd F
+GLIBC_2.40 dirname F
+GLIBC_2.40 div F
+GLIBC_2.40 dl_iterate_phdr F
+GLIBC_2.40 dladdr F
+GLIBC_2.40 dladdr1 F
+GLIBC_2.40 dlclose F
+GLIBC_2.40 dlerror F
+GLIBC_2.40 dlinfo F
+GLIBC_2.40 dlmopen F
+GLIBC_2.40 dlopen F
+GLIBC_2.40 dlsym F
+GLIBC_2.40 dlvsym F
+GLIBC_2.40 dn_comp F
+GLIBC_2.40 dn_expand F
+GLIBC_2.40 dn_skipname F
+GLIBC_2.40 dngettext F
+GLIBC_2.40 dprintf F
+GLIBC_2.40 drand48 F
+GLIBC_2.40 drand48_r F
+GLIBC_2.40 dup F
+GLIBC_2.40 dup2 F
+GLIBC_2.40 dup3 F
+GLIBC_2.40 duplocale F
+GLIBC_2.40 dysize F
+GLIBC_2.40 eaccess F
+GLIBC_2.40 ecvt F
+GLIBC_2.40 ecvt_r F
+GLIBC_2.40 endaliasent F
+GLIBC_2.40 endfsent F
+GLIBC_2.40 endgrent F
+GLIBC_2.40 endhostent F
+GLIBC_2.40 endmntent F
+GLIBC_2.40 endnetent F
+GLIBC_2.40 endnetgrent F
+GLIBC_2.40 endprotoent F
+GLIBC_2.40 endpwent F
+GLIBC_2.40 endrpcent F
+GLIBC_2.40 endservent F
+GLIBC_2.40 endsgent F
+GLIBC_2.40 endspent F
+GLIBC_2.40 endttyent F
+GLIBC_2.40 endusershell F
+GLIBC_2.40 endutent F
+GLIBC_2.40 endutxent F
+GLIBC_2.40 environ D 0x8
+GLIBC_2.40 envz_add F
+GLIBC_2.40 envz_entry F
+GLIBC_2.40 envz_get F
+GLIBC_2.40 envz_merge F
+GLIBC_2.40 envz_remove F
+GLIBC_2.40 envz_strip F
+GLIBC_2.40 erand48 F
+GLIBC_2.40 erand48_r F
+GLIBC_2.40 err F
+GLIBC_2.40 error F
+GLIBC_2.40 error_at_line F
+GLIBC_2.40 error_message_count D 0x4
+GLIBC_2.40 error_one_per_line D 0x4
+GLIBC_2.40 error_print_progname D 0x8
+GLIBC_2.40 errx F
+GLIBC_2.40 ether_aton F
+GLIBC_2.40 ether_aton_r F
+GLIBC_2.40 ether_hostton F
+GLIBC_2.40 ether_line F
+GLIBC_2.40 ether_ntoa F
+GLIBC_2.40 ether_ntoa_r F
+GLIBC_2.40 ether_ntohost F
+GLIBC_2.40 euidaccess F
+GLIBC_2.40 evc_wait F
+GLIBC_2.40 execl F
+GLIBC_2.40 execle F
+GLIBC_2.40 execlp F
+GLIBC_2.40 execv F
+GLIBC_2.40 execve F
+GLIBC_2.40 execveat F
+GLIBC_2.40 execvp F
+GLIBC_2.40 execvpe F
+GLIBC_2.40 exit F
+GLIBC_2.40 explicit_bzero F
+GLIBC_2.40 faccessat F
+GLIBC_2.40 fchdir F
+GLIBC_2.40 fchflags F
+GLIBC_2.40 fchmod F
+GLIBC_2.40 fchmodat F
+GLIBC_2.40 fchown F
+GLIBC_2.40 fchownat F
+GLIBC_2.40 fclose F
+GLIBC_2.40 fcloseall F
+GLIBC_2.40 fcntl F
+GLIBC_2.40 fcntl64 F
+GLIBC_2.40 fcvt F
+GLIBC_2.40 fcvt_r F
+GLIBC_2.40 fdatasync F
+GLIBC_2.40 fdopen F
+GLIBC_2.40 fdopendir F
+GLIBC_2.40 feof F
+GLIBC_2.40 feof_unlocked F
+GLIBC_2.40 ferror F
+GLIBC_2.40 ferror_unlocked F
+GLIBC_2.40 fexecve F
+GLIBC_2.40 fflush F
+GLIBC_2.40 fflush_unlocked F
+GLIBC_2.40 ffs F
+GLIBC_2.40 ffsl F
+GLIBC_2.40 ffsll F
+GLIBC_2.40 fgetc F
+GLIBC_2.40 fgetc_unlocked F
+GLIBC_2.40 fgetgrent F
+GLIBC_2.40 fgetgrent_r F
+GLIBC_2.40 fgetpos F
+GLIBC_2.40 fgetpos64 F
+GLIBC_2.40 fgetpwent F
+GLIBC_2.40 fgetpwent_r F
+GLIBC_2.40 fgets F
+GLIBC_2.40 fgets_unlocked F
+GLIBC_2.40 fgetsgent F
+GLIBC_2.40 fgetsgent_r F
+GLIBC_2.40 fgetspent F
+GLIBC_2.40 fgetspent_r F
+GLIBC_2.40 fgetwc F
+GLIBC_2.40 fgetwc_unlocked F
+GLIBC_2.40 fgetws F
+GLIBC_2.40 fgetws_unlocked F
+GLIBC_2.40 fgetxattr F
+GLIBC_2.40 file_name_lookup F
+GLIBC_2.40 file_name_lookup_under F
+GLIBC_2.40 file_name_path_lookup F
+GLIBC_2.40 file_name_split F
+GLIBC_2.40 fileno F
+GLIBC_2.40 fileno_unlocked F
+GLIBC_2.40 finite F
+GLIBC_2.40 finitef F
+GLIBC_2.40 finitel F
+GLIBC_2.40 flistxattr F
+GLIBC_2.40 flock F
+GLIBC_2.40 flockfile F
+GLIBC_2.40 fmemopen F
+GLIBC_2.40 fmtmsg F
+GLIBC_2.40 fnmatch F
+GLIBC_2.40 fopen F
+GLIBC_2.40 fopen64 F
+GLIBC_2.40 fopencookie F
+GLIBC_2.40 fopenport F
+GLIBC_2.40 fork F
+GLIBC_2.40 forkpty F
+GLIBC_2.40 fpathconf F
+GLIBC_2.40 fprintf F
+GLIBC_2.40 fputc F
+GLIBC_2.40 fputc_unlocked F
+GLIBC_2.40 fputs F
+GLIBC_2.40 fputs_unlocked F
+GLIBC_2.40 fputwc F
+GLIBC_2.40 fputwc_unlocked F
+GLIBC_2.40 fputws F
+GLIBC_2.40 fputws_unlocked F
+GLIBC_2.40 fread F
+GLIBC_2.40 fread_unlocked F
+GLIBC_2.40 free F
+GLIBC_2.40 freeaddrinfo F
+GLIBC_2.40 freeifaddrs F
+GLIBC_2.40 freelocale F
+GLIBC_2.40 fremovexattr F
+GLIBC_2.40 freopen F
+GLIBC_2.40 freopen64 F
+GLIBC_2.40 frexp F
+GLIBC_2.40 frexpf F
+GLIBC_2.40 frexpl F
+GLIBC_2.40 fscanf F
+GLIBC_2.40 fseek F
+GLIBC_2.40 fseeko F
+GLIBC_2.40 fseeko64 F
+GLIBC_2.40 fsetpos F
+GLIBC_2.40 fsetpos64 F
+GLIBC_2.40 fsetxattr F
+GLIBC_2.40 fstat F
+GLIBC_2.40 fstat64 F
+GLIBC_2.40 fstatat F
+GLIBC_2.40 fstatat64 F
+GLIBC_2.40 fstatfs F
+GLIBC_2.40 fstatfs64 F
+GLIBC_2.40 fstatvfs F
+GLIBC_2.40 fstatvfs64 F
+GLIBC_2.40 fsync F
+GLIBC_2.40 ftell F
+GLIBC_2.40 ftello F
+GLIBC_2.40 ftello64 F
+GLIBC_2.40 ftime F
+GLIBC_2.40 ftok F
+GLIBC_2.40 ftruncate F
+GLIBC_2.40 ftruncate64 F
+GLIBC_2.40 ftrylockfile F
+GLIBC_2.40 fts64_children F
+GLIBC_2.40 fts64_close F
+GLIBC_2.40 fts64_open F
+GLIBC_2.40 fts64_read F
+GLIBC_2.40 fts64_set F
+GLIBC_2.40 fts_children F
+GLIBC_2.40 fts_close F
+GLIBC_2.40 fts_open F
+GLIBC_2.40 fts_read F
+GLIBC_2.40 fts_set F
+GLIBC_2.40 ftw F
+GLIBC_2.40 ftw64 F
+GLIBC_2.40 funlockfile F
+GLIBC_2.40 futimens F
+GLIBC_2.40 futimes F
+GLIBC_2.40 futimesat F
+GLIBC_2.40 fwide F
+GLIBC_2.40 fwprintf F
+GLIBC_2.40 fwrite F
+GLIBC_2.40 fwrite_unlocked F
+GLIBC_2.40 fwscanf F
+GLIBC_2.40 gai_strerror F
+GLIBC_2.40 gcvt F
+GLIBC_2.40 get_avphys_pages F
+GLIBC_2.40 get_current_dir_name F
+GLIBC_2.40 get_nprocs F
+GLIBC_2.40 get_nprocs_conf F
+GLIBC_2.40 get_phys_pages F
+GLIBC_2.40 get_privileged_ports F
+GLIBC_2.40 getaddrinfo F
+GLIBC_2.40 getaliasbyname F
+GLIBC_2.40 getaliasbyname_r F
+GLIBC_2.40 getaliasent F
+GLIBC_2.40 getaliasent_r F
+GLIBC_2.40 getauth F
+GLIBC_2.40 getauxval F
+GLIBC_2.40 getc F
+GLIBC_2.40 getc_unlocked F
+GLIBC_2.40 getchar F
+GLIBC_2.40 getchar_unlocked F
+GLIBC_2.40 getcontext F
+GLIBC_2.40 getcrdir F
+GLIBC_2.40 getcttyid F
+GLIBC_2.40 getcwd F
+GLIBC_2.40 getcwdir F
+GLIBC_2.40 getdate F
+GLIBC_2.40 getdate_err D 0x4
+GLIBC_2.40 getdate_r F
+GLIBC_2.40 getdelim F
+GLIBC_2.40 getdirentries F
+GLIBC_2.40 getdirentries64 F
+GLIBC_2.40 getdomainname F
+GLIBC_2.40 getdport F
+GLIBC_2.40 getdtablesize F
+GLIBC_2.40 getegid F
+GLIBC_2.40 getentropy F
+GLIBC_2.40 getenv F
+GLIBC_2.40 geteuid F
+GLIBC_2.40 geteuids F
+GLIBC_2.40 getfsent F
+GLIBC_2.40 getfsfile F
+GLIBC_2.40 getfsspec F
+GLIBC_2.40 getgid F
+GLIBC_2.40 getgrent F
+GLIBC_2.40 getgrent_r F
+GLIBC_2.40 getgrgid F
+GLIBC_2.40 getgrgid_r F
+GLIBC_2.40 getgrnam F
+GLIBC_2.40 getgrnam_r F
+GLIBC_2.40 getgrouplist F
+GLIBC_2.40 getgroups F
+GLIBC_2.40 gethostbyaddr F
+GLIBC_2.40 gethostbyaddr_r F
+GLIBC_2.40 gethostbyname F
+GLIBC_2.40 gethostbyname2 F
+GLIBC_2.40 gethostbyname2_r F
+GLIBC_2.40 gethostbyname_r F
+GLIBC_2.40 gethostent F
+GLIBC_2.40 gethostent_r F
+GLIBC_2.40 gethostid F
+GLIBC_2.40 gethostname F
+GLIBC_2.40 getifaddrs F
+GLIBC_2.40 getipv4sourcefilter F
+GLIBC_2.40 getitimer F
+GLIBC_2.40 getline F
+GLIBC_2.40 getloadavg F
+GLIBC_2.40 getlogin F
+GLIBC_2.40 getlogin_r F
+GLIBC_2.40 getmntent F
+GLIBC_2.40 getmntent_r F
+GLIBC_2.40 getnameinfo F
+GLIBC_2.40 getnetbyaddr F
+GLIBC_2.40 getnetbyaddr_r F
+GLIBC_2.40 getnetbyname F
+GLIBC_2.40 getnetbyname_r F
+GLIBC_2.40 getnetent F
+GLIBC_2.40 getnetent_r F
+GLIBC_2.40 getnetgrent F
+GLIBC_2.40 getnetgrent_r F
+GLIBC_2.40 getopt F
+GLIBC_2.40 getopt_long F
+GLIBC_2.40 getopt_long_only F
+GLIBC_2.40 getpagesize F
+GLIBC_2.40 getpass F
+GLIBC_2.40 getpeername F
+GLIBC_2.40 getpgid F
+GLIBC_2.40 getpgrp F
+GLIBC_2.40 getpid F
+GLIBC_2.40 getppid F
+GLIBC_2.40 getpriority F
+GLIBC_2.40 getproc F
+GLIBC_2.40 getprotobyname F
+GLIBC_2.40 getprotobyname_r F
+GLIBC_2.40 getprotobynumber F
+GLIBC_2.40 getprotobynumber_r F
+GLIBC_2.40 getprotoent F
+GLIBC_2.40 getprotoent_r F
+GLIBC_2.40 getpt F
+GLIBC_2.40 getpw F
+GLIBC_2.40 getpwent F
+GLIBC_2.40 getpwent_r F
+GLIBC_2.40 getpwnam F
+GLIBC_2.40 getpwnam_r F
+GLIBC_2.40 getpwuid F
+GLIBC_2.40 getpwuid_r F
+GLIBC_2.40 getrandom F
+GLIBC_2.40 getresgid F
+GLIBC_2.40 getresuid F
+GLIBC_2.40 getrlimit F
+GLIBC_2.40 getrlimit64 F
+GLIBC_2.40 getrpcbyname F
+GLIBC_2.40 getrpcbyname_r F
+GLIBC_2.40 getrpcbynumber F
+GLIBC_2.40 getrpcbynumber_r F
+GLIBC_2.40 getrpcent F
+GLIBC_2.40 getrpcent_r F
+GLIBC_2.40 getrusage F
+GLIBC_2.40 gets F
+GLIBC_2.40 getservbyname F
+GLIBC_2.40 getservbyname_r F
+GLIBC_2.40 getservbyport F
+GLIBC_2.40 getservbyport_r F
+GLIBC_2.40 getservent F
+GLIBC_2.40 getservent_r F
+GLIBC_2.40 getsgent F
+GLIBC_2.40 getsgent_r F
+GLIBC_2.40 getsgnam F
+GLIBC_2.40 getsgnam_r F
+GLIBC_2.40 getsid F
+GLIBC_2.40 getsockname F
+GLIBC_2.40 getsockopt F
+GLIBC_2.40 getsourcefilter F
+GLIBC_2.40 getspent F
+GLIBC_2.40 getspent_r F
+GLIBC_2.40 getspnam F
+GLIBC_2.40 getspnam_r F
+GLIBC_2.40 getsubopt F
+GLIBC_2.40 gettext F
+GLIBC_2.40 gettimeofday F
+GLIBC_2.40 getttyent F
+GLIBC_2.40 getttynam F
+GLIBC_2.40 getuid F
+GLIBC_2.40 getumask F
+GLIBC_2.40 getusershell F
+GLIBC_2.40 getutent F
+GLIBC_2.40 getutent_r F
+GLIBC_2.40 getutid F
+GLIBC_2.40 getutid_r F
+GLIBC_2.40 getutline F
+GLIBC_2.40 getutline_r F
+GLIBC_2.40 getutmp F
+GLIBC_2.40 getutmpx F
+GLIBC_2.40 getutxent F
+GLIBC_2.40 getutxid F
+GLIBC_2.40 getutxline F
+GLIBC_2.40 getw F
+GLIBC_2.40 getwc F
+GLIBC_2.40 getwc_unlocked F
+GLIBC_2.40 getwchar F
+GLIBC_2.40 getwchar_unlocked F
+GLIBC_2.40 getwd F
+GLIBC_2.40 getxattr F
+GLIBC_2.40 glob F
+GLIBC_2.40 glob64 F
+GLIBC_2.40 glob_pattern_p F
+GLIBC_2.40 globfree F
+GLIBC_2.40 globfree64 F
+GLIBC_2.40 gmtime F
+GLIBC_2.40 gmtime_r F
+GLIBC_2.40 gnu_dev_major F
+GLIBC_2.40 gnu_dev_makedev F
+GLIBC_2.40 gnu_dev_minor F
+GLIBC_2.40 gnu_get_libc_release F
+GLIBC_2.40 gnu_get_libc_version F
+GLIBC_2.40 grantpt F
+GLIBC_2.40 group_member F
+GLIBC_2.40 gsignal F
+GLIBC_2.40 gtty F
+GLIBC_2.40 h_errlist D 0x28
+GLIBC_2.40 h_nerr D 0x4
+GLIBC_2.40 hasmntopt F
+GLIBC_2.40 hcreate F
+GLIBC_2.40 hcreate_r F
+GLIBC_2.40 hdestroy F
+GLIBC_2.40 hdestroy_r F
+GLIBC_2.40 herror F
+GLIBC_2.40 hsearch F
+GLIBC_2.40 hsearch_r F
+GLIBC_2.40 hstrerror F
+GLIBC_2.40 htonl F
+GLIBC_2.40 htons F
+GLIBC_2.40 hurd_catch_signal F
+GLIBC_2.40 hurd_check_cancel F
+GLIBC_2.40 hurd_directory_name_split F
+GLIBC_2.40 hurd_file_name_lookup F
+GLIBC_2.40 hurd_file_name_lookup_retry F
+GLIBC_2.40 hurd_file_name_path_lookup F
+GLIBC_2.40 hurd_file_name_split F
+GLIBC_2.40 hurd_preempt_signals F
+GLIBC_2.40 hurd_safe_copyin F
+GLIBC_2.40 hurd_safe_copyout F
+GLIBC_2.40 hurd_safe_memmove F
+GLIBC_2.40 hurd_safe_memset F
+GLIBC_2.40 hurd_sig_post F
+GLIBC_2.40 hurd_thread_cancel F
+GLIBC_2.40 hurd_thread_self F
+GLIBC_2.40 hurd_unpreempt_signals F
+GLIBC_2.40 iconv F
+GLIBC_2.40 iconv_close F
+GLIBC_2.40 iconv_open F
+GLIBC_2.40 if_freenameindex F
+GLIBC_2.40 if_indextoname F
+GLIBC_2.40 if_nameindex F
+GLIBC_2.40 if_nametoindex F
+GLIBC_2.40 imaxabs F
+GLIBC_2.40 imaxdiv F
+GLIBC_2.40 in6addr_any D 0x10
+GLIBC_2.40 in6addr_loopback D 0x10
+GLIBC_2.40 index F
+GLIBC_2.40 inet6_opt_append F
+GLIBC_2.40 inet6_opt_find F
+GLIBC_2.40 inet6_opt_finish F
+GLIBC_2.40 inet6_opt_get_val F
+GLIBC_2.40 inet6_opt_init F
+GLIBC_2.40 inet6_opt_next F
+GLIBC_2.40 inet6_opt_set_val F
+GLIBC_2.40 inet6_option_alloc F
+GLIBC_2.40 inet6_option_append F
+GLIBC_2.40 inet6_option_find F
+GLIBC_2.40 inet6_option_init F
+GLIBC_2.40 inet6_option_next F
+GLIBC_2.40 inet6_option_space F
+GLIBC_2.40 inet6_rth_add F
+GLIBC_2.40 inet6_rth_getaddr F
+GLIBC_2.40 inet6_rth_init F
+GLIBC_2.40 inet6_rth_reverse F
+GLIBC_2.40 inet6_rth_segments F
+GLIBC_2.40 inet6_rth_space F
+GLIBC_2.40 inet_addr F
+GLIBC_2.40 inet_aton F
+GLIBC_2.40 inet_lnaof F
+GLIBC_2.40 inet_makeaddr F
+GLIBC_2.40 inet_netof F
+GLIBC_2.40 inet_network F
+GLIBC_2.40 inet_nsap_addr F
+GLIBC_2.40 inet_nsap_ntoa F
+GLIBC_2.40 inet_ntoa F
+GLIBC_2.40 inet_ntop F
+GLIBC_2.40 inet_pton F
+GLIBC_2.40 initgroups F
+GLIBC_2.40 initstate F
+GLIBC_2.40 initstate_r F
+GLIBC_2.40 innetgr F
+GLIBC_2.40 insque F
+GLIBC_2.40 ioctl F
+GLIBC_2.40 iruserok F
+GLIBC_2.40 iruserok_af F
+GLIBC_2.40 isalnum F
+GLIBC_2.40 isalnum_l F
+GLIBC_2.40 isalpha F
+GLIBC_2.40 isalpha_l F
+GLIBC_2.40 isascii F
+GLIBC_2.40 isatty F
+GLIBC_2.40 isblank F
+GLIBC_2.40 isblank_l F
+GLIBC_2.40 iscntrl F
+GLIBC_2.40 iscntrl_l F
+GLIBC_2.40 isctype F
+GLIBC_2.40 isdigit F
+GLIBC_2.40 isdigit_l F
+GLIBC_2.40 isfdtype F
+GLIBC_2.40 isgraph F
+GLIBC_2.40 isgraph_l F
+GLIBC_2.40 isinf F
+GLIBC_2.40 isinff F
+GLIBC_2.40 isinfl F
+GLIBC_2.40 islower F
+GLIBC_2.40 islower_l F
+GLIBC_2.40 isnan F
+GLIBC_2.40 isnanf F
+GLIBC_2.40 isnanl F
+GLIBC_2.40 isprint F
+GLIBC_2.40 isprint_l F
+GLIBC_2.40 ispunct F
+GLIBC_2.40 ispunct_l F
+GLIBC_2.40 isspace F
+GLIBC_2.40 isspace_l F
+GLIBC_2.40 isupper F
+GLIBC_2.40 isupper_l F
+GLIBC_2.40 iswalnum F
+GLIBC_2.40 iswalnum_l F
+GLIBC_2.40 iswalpha F
+GLIBC_2.40 iswalpha_l F
+GLIBC_2.40 iswblank F
+GLIBC_2.40 iswblank_l F
+GLIBC_2.40 iswcntrl F
+GLIBC_2.40 iswcntrl_l F
+GLIBC_2.40 iswctype F
+GLIBC_2.40 iswctype_l F
+GLIBC_2.40 iswdigit F
+GLIBC_2.40 iswdigit_l F
+GLIBC_2.40 iswgraph F
+GLIBC_2.40 iswgraph_l F
+GLIBC_2.40 iswlower F
+GLIBC_2.40 iswlower_l F
+GLIBC_2.40 iswprint F
+GLIBC_2.40 iswprint_l F
+GLIBC_2.40 iswpunct F
+GLIBC_2.40 iswpunct_l F
+GLIBC_2.40 iswspace F
+GLIBC_2.40 iswspace_l F
+GLIBC_2.40 iswupper F
+GLIBC_2.40 iswupper_l F
+GLIBC_2.40 iswxdigit F
+GLIBC_2.40 iswxdigit_l F
+GLIBC_2.40 isxdigit F
+GLIBC_2.40 isxdigit_l F
+GLIBC_2.40 jrand48 F
+GLIBC_2.40 jrand48_r F
+GLIBC_2.40 kill F
+GLIBC_2.40 killpg F
+GLIBC_2.40 l64a F
+GLIBC_2.40 labs F
+GLIBC_2.40 lchmod F
+GLIBC_2.40 lchown F
+GLIBC_2.40 lckpwdf F
+GLIBC_2.40 lcong48 F
+GLIBC_2.40 lcong48_r F
+GLIBC_2.40 ldexp F
+GLIBC_2.40 ldexpf F
+GLIBC_2.40 ldexpl F
+GLIBC_2.40 ldiv F
+GLIBC_2.40 lfind F
+GLIBC_2.40 lgetxattr F
+GLIBC_2.40 link F
+GLIBC_2.40 linkat F
+GLIBC_2.40 listen F
+GLIBC_2.40 listxattr F
+GLIBC_2.40 llabs F
+GLIBC_2.40 lldiv F
+GLIBC_2.40 llistxattr F
+GLIBC_2.40 localeconv F
+GLIBC_2.40 localtime F
+GLIBC_2.40 localtime_r F
+GLIBC_2.40 lockf F
+GLIBC_2.40 lockf64 F
+GLIBC_2.40 login F
+GLIBC_2.40 login_tty F
+GLIBC_2.40 logout F
+GLIBC_2.40 logwtmp F
+GLIBC_2.40 longjmp F
+GLIBC_2.40 lrand48 F
+GLIBC_2.40 lrand48_r F
+GLIBC_2.40 lremovexattr F
+GLIBC_2.40 lsearch F
+GLIBC_2.40 lseek F
+GLIBC_2.40 lseek64 F
+GLIBC_2.40 lsetxattr F
+GLIBC_2.40 lstat F
+GLIBC_2.40 lstat64 F
+GLIBC_2.40 lutimes F
+GLIBC_2.40 mach_error F
+GLIBC_2.40 mach_error_string F
+GLIBC_2.40 mach_error_type F
+GLIBC_2.40 mach_host_self F
+GLIBC_2.40 mach_msg F
+GLIBC_2.40 mach_msg_destroy F
+GLIBC_2.40 mach_msg_receive F
+GLIBC_2.40 mach_msg_send F
+GLIBC_2.40 mach_msg_server F
+GLIBC_2.40 mach_msg_server_timeout F
+GLIBC_2.40 mach_open_devstream F
+GLIBC_2.40 mach_port_allocate F
+GLIBC_2.40 mach_port_allocate_name F
+GLIBC_2.40 mach_port_deallocate F
+GLIBC_2.40 mach_port_insert_right F
+GLIBC_2.40 mach_print F
+GLIBC_2.40 mach_reply_port F
+GLIBC_2.40 mach_setup_thread F
+GLIBC_2.40 mach_setup_tls F
+GLIBC_2.40 mach_task_self F
+GLIBC_2.40 mach_thread_self F
+GLIBC_2.40 madvise F
+GLIBC_2.40 makecontext F
+GLIBC_2.40 mallinfo F
+GLIBC_2.40 mallinfo2 F
+GLIBC_2.40 malloc F
+GLIBC_2.40 malloc_info F
+GLIBC_2.40 malloc_stats F
+GLIBC_2.40 malloc_trim F
+GLIBC_2.40 malloc_usable_size F
+GLIBC_2.40 mallopt F
+GLIBC_2.40 mblen F
+GLIBC_2.40 mbrlen F
+GLIBC_2.40 mbrtoc16 F
+GLIBC_2.40 mbrtoc32 F
+GLIBC_2.40 mbrtoc8 F
+GLIBC_2.40 mbrtowc F
+GLIBC_2.40 mbsinit F
+GLIBC_2.40 mbsnrtowcs F
+GLIBC_2.40 mbsrtowcs F
+GLIBC_2.40 mbstowcs F
+GLIBC_2.40 mbtowc F
+GLIBC_2.40 mcheck F
+GLIBC_2.40 mcheck_check_all F
+GLIBC_2.40 mcheck_pedantic F
+GLIBC_2.40 memalign F
+GLIBC_2.40 memccpy F
+GLIBC_2.40 memchr F
+GLIBC_2.40 memcmp F
+GLIBC_2.40 memcpy F
+GLIBC_2.40 memfrob F
+GLIBC_2.40 memmem F
+GLIBC_2.40 memmove F
+GLIBC_2.40 mempcpy F
+GLIBC_2.40 memrchr F
+GLIBC_2.40 memset F
+GLIBC_2.40 mig_allocate F
+GLIBC_2.40 mig_dealloc_reply_port F
+GLIBC_2.40 mig_deallocate F
+GLIBC_2.40 mig_get_reply_port F
+GLIBC_2.40 mig_init F
+GLIBC_2.40 mig_put_reply_port F
+GLIBC_2.40 mig_strncpy F
+GLIBC_2.40 mincore F
+GLIBC_2.40 mkdir F
+GLIBC_2.40 mkdirat F
+GLIBC_2.40 mkdtemp F
+GLIBC_2.40 mkfifo F
+GLIBC_2.40 mkfifoat F
+GLIBC_2.40 mknod F
+GLIBC_2.40 mknodat F
+GLIBC_2.40 mkostemp F
+GLIBC_2.40 mkostemp64 F
+GLIBC_2.40 mkostemps F
+GLIBC_2.40 mkostemps64 F
+GLIBC_2.40 mkstemp F
+GLIBC_2.40 mkstemp64 F
+GLIBC_2.40 mkstemps F
+GLIBC_2.40 mkstemps64 F
+GLIBC_2.40 mktemp F
+GLIBC_2.40 mktime F
+GLIBC_2.40 mlock F
+GLIBC_2.40 mlockall F
+GLIBC_2.40 mmap F
+GLIBC_2.40 mmap64 F
+GLIBC_2.40 modf F
+GLIBC_2.40 modff F
+GLIBC_2.40 modfl F
+GLIBC_2.40 moncontrol F
+GLIBC_2.40 monstartup F
+GLIBC_2.40 mprobe F
+GLIBC_2.40 mprotect F
+GLIBC_2.40 mrand48 F
+GLIBC_2.40 mrand48_r F
+GLIBC_2.40 mremap F
+GLIBC_2.40 msgctl F
+GLIBC_2.40 msgget F
+GLIBC_2.40 msgrcv F
+GLIBC_2.40 msgsnd F
+GLIBC_2.40 msync F
+GLIBC_2.40 mtrace F
+GLIBC_2.40 munlock F
+GLIBC_2.40 munlockall F
+GLIBC_2.40 munmap F
+GLIBC_2.40 muntrace F
+GLIBC_2.40 nanosleep F
+GLIBC_2.40 newlocale F
+GLIBC_2.40 nftw F
+GLIBC_2.40 nftw64 F
+GLIBC_2.40 ngettext F
+GLIBC_2.40 nice F
+GLIBC_2.40 nl_langinfo F
+GLIBC_2.40 nl_langinfo_l F
+GLIBC_2.40 nrand48 F
+GLIBC_2.40 nrand48_r F
+GLIBC_2.40 ns_name_compress F
+GLIBC_2.40 ns_name_ntop F
+GLIBC_2.40 ns_name_pack F
+GLIBC_2.40 ns_name_pton F
+GLIBC_2.40 ns_name_skip F
+GLIBC_2.40 ns_name_uncompress F
+GLIBC_2.40 ns_name_unpack F
+GLIBC_2.40 ntohl F
+GLIBC_2.40 ntohs F
+GLIBC_2.40 obstack_alloc_failed_handler D 0x8
+GLIBC_2.40 obstack_exit_failure D 0x4
+GLIBC_2.40 obstack_free F
+GLIBC_2.40 obstack_printf F
+GLIBC_2.40 obstack_vprintf F
+GLIBC_2.40 on_exit F
+GLIBC_2.40 open F
+GLIBC_2.40 open64 F
+GLIBC_2.40 open_memstream F
+GLIBC_2.40 open_wmemstream F
+GLIBC_2.40 openat F
+GLIBC_2.40 openat64 F
+GLIBC_2.40 opendir F
+GLIBC_2.40 openlog F
+GLIBC_2.40 openport F
+GLIBC_2.40 openpty F
+GLIBC_2.40 optarg D 0x8
+GLIBC_2.40 opterr D 0x4
+GLIBC_2.40 optind D 0x4
+GLIBC_2.40 optopt D 0x4
+GLIBC_2.40 parse_printf_format F
+GLIBC_2.40 pathconf F
+GLIBC_2.40 pause F
+GLIBC_2.40 pclose F
+GLIBC_2.40 perror F
+GLIBC_2.40 pid2task F
+GLIBC_2.40 pipe F
+GLIBC_2.40 pipe2 F
+GLIBC_2.40 poll F
+GLIBC_2.40 popen F
+GLIBC_2.40 posix_fadvise F
+GLIBC_2.40 posix_fadvise64 F
+GLIBC_2.40 posix_fallocate F
+GLIBC_2.40 posix_fallocate64 F
+GLIBC_2.40 posix_madvise F
+GLIBC_2.40 posix_memalign F
+GLIBC_2.40 posix_openpt F
+GLIBC_2.40 posix_spawn F
+GLIBC_2.40 posix_spawn_file_actions_addchdir_np F
+GLIBC_2.40 posix_spawn_file_actions_addclose F
+GLIBC_2.40 posix_spawn_file_actions_addclosefrom_np F
+GLIBC_2.40 posix_spawn_file_actions_adddup2 F
+GLIBC_2.40 posix_spawn_file_actions_addfchdir_np F
+GLIBC_2.40 posix_spawn_file_actions_addopen F
+GLIBC_2.40 posix_spawn_file_actions_addtcsetpgrp_np F
+GLIBC_2.40 posix_spawn_file_actions_destroy F
+GLIBC_2.40 posix_spawn_file_actions_init F
+GLIBC_2.40 posix_spawnattr_destroy F
+GLIBC_2.40 posix_spawnattr_getflags F
+GLIBC_2.40 posix_spawnattr_getpgroup F
+GLIBC_2.40 posix_spawnattr_getschedparam F
+GLIBC_2.40 posix_spawnattr_getschedpolicy F
+GLIBC_2.40 posix_spawnattr_getsigdefault F
+GLIBC_2.40 posix_spawnattr_getsigmask F
+GLIBC_2.40 posix_spawnattr_init F
+GLIBC_2.40 posix_spawnattr_setflags F
+GLIBC_2.40 posix_spawnattr_setpgroup F
+GLIBC_2.40 posix_spawnattr_setschedparam F
+GLIBC_2.40 posix_spawnattr_setschedpolicy F
+GLIBC_2.40 posix_spawnattr_setsigdefault F
+GLIBC_2.40 posix_spawnattr_setsigmask F
+GLIBC_2.40 posix_spawnp F
+GLIBC_2.40 ppoll F
+GLIBC_2.40 pread F
+GLIBC_2.40 pread64 F
+GLIBC_2.40 preadv F
+GLIBC_2.40 preadv2 F
+GLIBC_2.40 preadv64 F
+GLIBC_2.40 preadv64v2 F
+GLIBC_2.40 printf F
+GLIBC_2.40 printf_size F
+GLIBC_2.40 printf_size_info F
+GLIBC_2.40 profil F
+GLIBC_2.40 program_invocation_name D 0x8
+GLIBC_2.40 program_invocation_short_name D 0x8
+GLIBC_2.40 pselect F
+GLIBC_2.40 psiginfo F
+GLIBC_2.40 psignal F
+GLIBC_2.40 pthread_attr_destroy F
+GLIBC_2.40 pthread_attr_getdetachstate F
+GLIBC_2.40 pthread_attr_getinheritsched F
+GLIBC_2.40 pthread_attr_getschedparam F
+GLIBC_2.40 pthread_attr_getschedpolicy F
+GLIBC_2.40 pthread_attr_getscope F
+GLIBC_2.40 pthread_attr_init F
+GLIBC_2.40 pthread_attr_setdetachstate F
+GLIBC_2.40 pthread_attr_setinheritsched F
+GLIBC_2.40 pthread_attr_setschedparam F
+GLIBC_2.40 pthread_attr_setschedpolicy F
+GLIBC_2.40 pthread_attr_setscope F
+GLIBC_2.40 pthread_cond_broadcast F
+GLIBC_2.40 pthread_cond_destroy F
+GLIBC_2.40 pthread_cond_init F
+GLIBC_2.40 pthread_cond_signal F
+GLIBC_2.40 pthread_cond_timedwait F
+GLIBC_2.40 pthread_cond_wait F
+GLIBC_2.40 pthread_condattr_destroy F
+GLIBC_2.40 pthread_condattr_init F
+GLIBC_2.40 pthread_equal F
+GLIBC_2.40 pthread_exit F
+GLIBC_2.40 pthread_getschedparam F
+GLIBC_2.40 pthread_mutex_destroy F
+GLIBC_2.40 pthread_mutex_init F
+GLIBC_2.40 pthread_mutex_lock F
+GLIBC_2.40 pthread_mutex_unlock F
+GLIBC_2.40 pthread_self F
+GLIBC_2.40 pthread_setcancelstate F
+GLIBC_2.40 pthread_setcanceltype F
+GLIBC_2.40 pthread_setschedparam F
+GLIBC_2.40 ptrace F
+GLIBC_2.40 ptsname F
+GLIBC_2.40 ptsname_r F
+GLIBC_2.40 putc F
+GLIBC_2.40 putc_unlocked F
+GLIBC_2.40 putchar F
+GLIBC_2.40 putchar_unlocked F
+GLIBC_2.40 putenv F
+GLIBC_2.40 putgrent F
+GLIBC_2.40 putpwent F
+GLIBC_2.40 puts F
+GLIBC_2.40 putsgent F
+GLIBC_2.40 putspent F
+GLIBC_2.40 pututline F
+GLIBC_2.40 pututxline F
+GLIBC_2.40 putw F
+GLIBC_2.40 putwc F
+GLIBC_2.40 putwc_unlocked F
+GLIBC_2.40 putwchar F
+GLIBC_2.40 putwchar_unlocked F
+GLIBC_2.40 pvalloc F
+GLIBC_2.40 pwrite F
+GLIBC_2.40 pwrite64 F
+GLIBC_2.40 pwritev F
+GLIBC_2.40 pwritev2 F
+GLIBC_2.40 pwritev64 F
+GLIBC_2.40 pwritev64v2 F
+GLIBC_2.40 qecvt F
+GLIBC_2.40 qecvt_r F
+GLIBC_2.40 qfcvt F
+GLIBC_2.40 qfcvt_r F
+GLIBC_2.40 qgcvt F
+GLIBC_2.40 qsort F
+GLIBC_2.40 qsort_r F
+GLIBC_2.40 quick_exit F
+GLIBC_2.40 raise F
+GLIBC_2.40 rand F
+GLIBC_2.40 rand_r F
+GLIBC_2.40 random F
+GLIBC_2.40 random_r F
+GLIBC_2.40 rawmemchr F
+GLIBC_2.40 rcmd F
+GLIBC_2.40 rcmd_af F
+GLIBC_2.40 re_comp F
+GLIBC_2.40 re_compile_fastmap F
+GLIBC_2.40 re_compile_pattern F
+GLIBC_2.40 re_exec F
+GLIBC_2.40 re_match F
+GLIBC_2.40 re_match_2 F
+GLIBC_2.40 re_search F
+GLIBC_2.40 re_search_2 F
+GLIBC_2.40 re_set_registers F
+GLIBC_2.40 re_set_syntax F
+GLIBC_2.40 re_syntax_options D 0x8
+GLIBC_2.40 read F
+GLIBC_2.40 readdir F
+GLIBC_2.40 readdir64 F
+GLIBC_2.40 readdir64_r F
+GLIBC_2.40 readdir_r F
+GLIBC_2.40 readlink F
+GLIBC_2.40 readlinkat F
+GLIBC_2.40 readv F
+GLIBC_2.40 realloc F
+GLIBC_2.40 reallocarray F
+GLIBC_2.40 realpath F
+GLIBC_2.40 reboot F
+GLIBC_2.40 recv F
+GLIBC_2.40 recvfrom F
+GLIBC_2.40 recvmmsg F
+GLIBC_2.40 recvmsg F
+GLIBC_2.40 regcomp F
+GLIBC_2.40 regerror F
+GLIBC_2.40 regexec F
+GLIBC_2.40 regfree F
+GLIBC_2.40 register_printf_function F
+GLIBC_2.40 register_printf_modifier F
+GLIBC_2.40 register_printf_specifier F
+GLIBC_2.40 register_printf_type F
+GLIBC_2.40 remap_file_pages F
+GLIBC_2.40 remove F
+GLIBC_2.40 removexattr F
+GLIBC_2.40 remque F
+GLIBC_2.40 rename F
+GLIBC_2.40 renameat F
+GLIBC_2.40 renameat2 F
+GLIBC_2.40 res_dnok F
+GLIBC_2.40 res_hnok F
+GLIBC_2.40 res_mailok F
+GLIBC_2.40 res_mkquery F
+GLIBC_2.40 res_nmkquery F
+GLIBC_2.40 res_nquery F
+GLIBC_2.40 res_nquerydomain F
+GLIBC_2.40 res_nsearch F
+GLIBC_2.40 res_nsend F
+GLIBC_2.40 res_ownok F
+GLIBC_2.40 res_query F
+GLIBC_2.40 res_querydomain F
+GLIBC_2.40 res_search F
+GLIBC_2.40 res_send F
+GLIBC_2.40 revoke F
+GLIBC_2.40 rewind F
+GLIBC_2.40 rewinddir F
+GLIBC_2.40 rexec F
+GLIBC_2.40 rexec_af F
+GLIBC_2.40 rexecoptions D 0x4
+GLIBC_2.40 rindex F
+GLIBC_2.40 rmdir F
+GLIBC_2.40 rpmatch F
+GLIBC_2.40 rresvport F
+GLIBC_2.40 rresvport_af F
+GLIBC_2.40 ruserok F
+GLIBC_2.40 ruserok_af F
+GLIBC_2.40 ruserpass F
+GLIBC_2.40 sbrk F
+GLIBC_2.40 scalbn F
+GLIBC_2.40 scalbnf F
+GLIBC_2.40 scalbnl F
+GLIBC_2.40 scandir F
+GLIBC_2.40 scandir64 F
+GLIBC_2.40 scandirat F
+GLIBC_2.40 scandirat64 F
+GLIBC_2.40 scanf F
+GLIBC_2.40 sched_get_priority_max F
+GLIBC_2.40 sched_get_priority_min F
+GLIBC_2.40 sched_getaffinity F
+GLIBC_2.40 sched_getparam F
+GLIBC_2.40 sched_getscheduler F
+GLIBC_2.40 sched_rr_get_interval F
+GLIBC_2.40 sched_setaffinity F
+GLIBC_2.40 sched_setparam F
+GLIBC_2.40 sched_setscheduler F
+GLIBC_2.40 sched_yield F
+GLIBC_2.40 secure_getenv F
+GLIBC_2.40 seed48 F
+GLIBC_2.40 seed48_r F
+GLIBC_2.40 seekdir F
+GLIBC_2.40 select F
+GLIBC_2.40 semctl F
+GLIBC_2.40 semget F
+GLIBC_2.40 semop F
+GLIBC_2.40 semtimedop F
+GLIBC_2.40 send F
+GLIBC_2.40 sendfile F
+GLIBC_2.40 sendfile64 F
+GLIBC_2.40 sendmmsg F
+GLIBC_2.40 sendmsg F
+GLIBC_2.40 sendto F
+GLIBC_2.40 setaliasent F
+GLIBC_2.40 setauth F
+GLIBC_2.40 setbuf F
+GLIBC_2.40 setbuffer F
+GLIBC_2.40 setcontext F
+GLIBC_2.40 setcrdir F
+GLIBC_2.40 setcttyid F
+GLIBC_2.40 setcwdir F
+GLIBC_2.40 setdomainname F
+GLIBC_2.40 setegid F
+GLIBC_2.40 setenv F
+GLIBC_2.40 seteuid F
+GLIBC_2.40 seteuids F
+GLIBC_2.40 setfsent F
+GLIBC_2.40 setgid F
+GLIBC_2.40 setgrent F
+GLIBC_2.40 setgroups F
+GLIBC_2.40 sethostent F
+GLIBC_2.40 sethostid F
+GLIBC_2.40 sethostname F
+GLIBC_2.40 setipv4sourcefilter F
+GLIBC_2.40 setitimer F
+GLIBC_2.40 setjmp F
+GLIBC_2.40 setlinebuf F
+GLIBC_2.40 setlocale F
+GLIBC_2.40 setlogin F
+GLIBC_2.40 setlogmask F
+GLIBC_2.40 setmntent F
+GLIBC_2.40 setnetent F
+GLIBC_2.40 setnetgrent F
+GLIBC_2.40 setpgid F
+GLIBC_2.40 setpgrp F
+GLIBC_2.40 setpriority F
+GLIBC_2.40 setproc F
+GLIBC_2.40 setprotoent F
+GLIBC_2.40 setpwent F
+GLIBC_2.40 setregid F
+GLIBC_2.40 setresgid F
+GLIBC_2.40 setresuid F
+GLIBC_2.40 setreuid F
+GLIBC_2.40 setrlimit F
+GLIBC_2.40 setrlimit64 F
+GLIBC_2.40 setrpcent F
+GLIBC_2.40 setservent F
+GLIBC_2.40 setsgent F
+GLIBC_2.40 setsid F
+GLIBC_2.40 setsockopt F
+GLIBC_2.40 setsourcefilter F
+GLIBC_2.40 setspent F
+GLIBC_2.40 setstate F
+GLIBC_2.40 setstate_r F
+GLIBC_2.40 settimeofday F
+GLIBC_2.40 setttyent F
+GLIBC_2.40 setuid F
+GLIBC_2.40 setusershell F
+GLIBC_2.40 setutent F
+GLIBC_2.40 setutxent F
+GLIBC_2.40 setvbuf F
+GLIBC_2.40 setxattr F
+GLIBC_2.40 sgetsgent F
+GLIBC_2.40 sgetsgent_r F
+GLIBC_2.40 sgetspent F
+GLIBC_2.40 sgetspent_r F
+GLIBC_2.40 shm_open F
+GLIBC_2.40 shm_unlink F
+GLIBC_2.40 shmat F
+GLIBC_2.40 shmctl F
+GLIBC_2.40 shmdt F
+GLIBC_2.40 shmget F
+GLIBC_2.40 shutdown F
+GLIBC_2.40 sigabbrev_np F
+GLIBC_2.40 sigaction F
+GLIBC_2.40 sigaddset F
+GLIBC_2.40 sigaltstack F
+GLIBC_2.40 sigandset F
+GLIBC_2.40 sigblock F
+GLIBC_2.40 sigdelset F
+GLIBC_2.40 sigdescr_np F
+GLIBC_2.40 sigemptyset F
+GLIBC_2.40 sigfillset F
+GLIBC_2.40 siggetmask F
+GLIBC_2.40 sighold F
+GLIBC_2.40 sigignore F
+GLIBC_2.40 siginterrupt F
+GLIBC_2.40 sigisemptyset F
+GLIBC_2.40 sigismember F
+GLIBC_2.40 siglongjmp F
+GLIBC_2.40 signal F
+GLIBC_2.40 sigorset F
+GLIBC_2.40 sigpause F
+GLIBC_2.40 sigpending F
+GLIBC_2.40 sigprocmask F
+GLIBC_2.40 sigqueue F
+GLIBC_2.40 sigrelse F
+GLIBC_2.40 sigreturn F
+GLIBC_2.40 sigset F
+GLIBC_2.40 sigsetmask F
+GLIBC_2.40 sigstack F
+GLIBC_2.40 sigsuspend F
+GLIBC_2.40 sigtimedwait F
+GLIBC_2.40 sigwait F
+GLIBC_2.40 sigwaitinfo F
+GLIBC_2.40 sleep F
+GLIBC_2.40 snprintf F
+GLIBC_2.40 sockatmark F
+GLIBC_2.40 socket F
+GLIBC_2.40 socketpair F
+GLIBC_2.40 sprintf F
+GLIBC_2.40 sprofil F
+GLIBC_2.40 srand F
+GLIBC_2.40 srand48 F
+GLIBC_2.40 srand48_r F
+GLIBC_2.40 srandom F
+GLIBC_2.40 srandom_r F
+GLIBC_2.40 sscanf F
+GLIBC_2.40 ssignal F
+GLIBC_2.40 stat F
+GLIBC_2.40 stat64 F
+GLIBC_2.40 statfs F
+GLIBC_2.40 statfs64 F
+GLIBC_2.40 statvfs F
+GLIBC_2.40 statvfs64 F
+GLIBC_2.40 statx F
+GLIBC_2.40 stdc_bit_ceil_uc F
+GLIBC_2.40 stdc_bit_ceil_ui F
+GLIBC_2.40 stdc_bit_ceil_ul F
+GLIBC_2.40 stdc_bit_ceil_ull F
+GLIBC_2.40 stdc_bit_ceil_us F
+GLIBC_2.40 stdc_bit_floor_uc F
+GLIBC_2.40 stdc_bit_floor_ui F
+GLIBC_2.40 stdc_bit_floor_ul F
+GLIBC_2.40 stdc_bit_floor_ull F
+GLIBC_2.40 stdc_bit_floor_us F
+GLIBC_2.40 stdc_bit_width_uc F
+GLIBC_2.40 stdc_bit_width_ui F
+GLIBC_2.40 stdc_bit_width_ul F
+GLIBC_2.40 stdc_bit_width_ull F
+GLIBC_2.40 stdc_bit_width_us F
+GLIBC_2.40 stdc_count_ones_uc F
+GLIBC_2.40 stdc_count_ones_ui F
+GLIBC_2.40 stdc_count_ones_ul F
+GLIBC_2.40 stdc_count_ones_ull F
+GLIBC_2.40 stdc_count_ones_us F
+GLIBC_2.40 stdc_count_zeros_uc F
+GLIBC_2.40 stdc_count_zeros_ui F
+GLIBC_2.40 stdc_count_zeros_ul F
+GLIBC_2.40 stdc_count_zeros_ull F
+GLIBC_2.40 stdc_count_zeros_us F
+GLIBC_2.40 stdc_first_leading_one_uc F
+GLIBC_2.40 stdc_first_leading_one_ui F
+GLIBC_2.40 stdc_first_leading_one_ul F
+GLIBC_2.40 stdc_first_leading_one_ull F
+GLIBC_2.40 stdc_first_leading_one_us F
+GLIBC_2.40 stdc_first_leading_zero_uc F
+GLIBC_2.40 stdc_first_leading_zero_ui F
+GLIBC_2.40 stdc_first_leading_zero_ul F
+GLIBC_2.40 stdc_first_leading_zero_ull F
+GLIBC_2.40 stdc_first_leading_zero_us F
+GLIBC_2.40 stdc_first_trailing_one_uc F
+GLIBC_2.40 stdc_first_trailing_one_ui F
+GLIBC_2.40 stdc_first_trailing_one_ul F
+GLIBC_2.40 stdc_first_trailing_one_ull F
+GLIBC_2.40 stdc_first_trailing_one_us F
+GLIBC_2.40 stdc_first_trailing_zero_uc F
+GLIBC_2.40 stdc_first_trailing_zero_ui F
+GLIBC_2.40 stdc_first_trailing_zero_ul F
+GLIBC_2.40 stdc_first_trailing_zero_ull F
+GLIBC_2.40 stdc_first_trailing_zero_us F
+GLIBC_2.40 stdc_has_single_bit_uc F
+GLIBC_2.40 stdc_has_single_bit_ui F
+GLIBC_2.40 stdc_has_single_bit_ul F
+GLIBC_2.40 stdc_has_single_bit_ull F
+GLIBC_2.40 stdc_has_single_bit_us F
+GLIBC_2.40 stdc_leading_ones_uc F
+GLIBC_2.40 stdc_leading_ones_ui F
+GLIBC_2.40 stdc_leading_ones_ul F
+GLIBC_2.40 stdc_leading_ones_ull F
+GLIBC_2.40 stdc_leading_ones_us F
+GLIBC_2.40 stdc_leading_zeros_uc F
+GLIBC_2.40 stdc_leading_zeros_ui F
+GLIBC_2.40 stdc_leading_zeros_ul F
+GLIBC_2.40 stdc_leading_zeros_ull F
+GLIBC_2.40 stdc_leading_zeros_us F
+GLIBC_2.40 stdc_trailing_ones_uc F
+GLIBC_2.40 stdc_trailing_ones_ui F
+GLIBC_2.40 stdc_trailing_ones_ul F
+GLIBC_2.40 stdc_trailing_ones_ull F
+GLIBC_2.40 stdc_trailing_ones_us F
+GLIBC_2.40 stdc_trailing_zeros_uc F
+GLIBC_2.40 stdc_trailing_zeros_ui F
+GLIBC_2.40 stdc_trailing_zeros_ul F
+GLIBC_2.40 stdc_trailing_zeros_ull F
+GLIBC_2.40 stdc_trailing_zeros_us F
+GLIBC_2.40 stderr D 0x8
+GLIBC_2.40 stdin D 0x8
+GLIBC_2.40 stdout D 0x8
+GLIBC_2.40 stpcpy F
+GLIBC_2.40 stpncpy F
+GLIBC_2.40 strcasecmp F
+GLIBC_2.40 strcasecmp_l F
+GLIBC_2.40 strcasestr F
+GLIBC_2.40 strcat F
+GLIBC_2.40 strchr F
+GLIBC_2.40 strchrnul F
+GLIBC_2.40 strcmp F
+GLIBC_2.40 strcoll F
+GLIBC_2.40 strcoll_l F
+GLIBC_2.40 strcpy F
+GLIBC_2.40 strcspn F
+GLIBC_2.40 strdup F
+GLIBC_2.40 strerror F
+GLIBC_2.40 strerror_l F
+GLIBC_2.40 strerror_r F
+GLIBC_2.40 strerrordesc_np F
+GLIBC_2.40 strerrorname_np F
+GLIBC_2.40 strfmon F
+GLIBC_2.40 strfmon_l F
+GLIBC_2.40 strfromd F
+GLIBC_2.40 strfromf F
+GLIBC_2.40 strfromf128 F
+GLIBC_2.40 strfromf32 F
+GLIBC_2.40 strfromf32x F
+GLIBC_2.40 strfromf64 F
+GLIBC_2.40 strfromf64x F
+GLIBC_2.40 strfroml F
+GLIBC_2.40 strfry F
+GLIBC_2.40 strftime F
+GLIBC_2.40 strftime_l F
+GLIBC_2.40 strlcat F
+GLIBC_2.40 strlcpy F
+GLIBC_2.40 strlen F
+GLIBC_2.40 strncasecmp F
+GLIBC_2.40 strncasecmp_l F
+GLIBC_2.40 strncat F
+GLIBC_2.40 strncmp F
+GLIBC_2.40 strncpy F
+GLIBC_2.40 strndup F
+GLIBC_2.40 strnlen F
+GLIBC_2.40 strpbrk F
+GLIBC_2.40 strptime F
+GLIBC_2.40 strptime_l F
+GLIBC_2.40 strrchr F
+GLIBC_2.40 strsep F
+GLIBC_2.40 strsignal F
+GLIBC_2.40 strspn F
+GLIBC_2.40 strstr F
+GLIBC_2.40 strtod F
+GLIBC_2.40 strtod_l F
+GLIBC_2.40 strtof F
+GLIBC_2.40 strtof128 F
+GLIBC_2.40 strtof128_l F
+GLIBC_2.40 strtof32 F
+GLIBC_2.40 strtof32_l F
+GLIBC_2.40 strtof32x F
+GLIBC_2.40 strtof32x_l F
+GLIBC_2.40 strtof64 F
+GLIBC_2.40 strtof64_l F
+GLIBC_2.40 strtof64x F
+GLIBC_2.40 strtof64x_l F
+GLIBC_2.40 strtof_l F
+GLIBC_2.40 strtoimax F
+GLIBC_2.40 strtok F
+GLIBC_2.40 strtok_r F
+GLIBC_2.40 strtol F
+GLIBC_2.40 strtol_l F
+GLIBC_2.40 strtold F
+GLIBC_2.40 strtold_l F
+GLIBC_2.40 strtoll F
+GLIBC_2.40 strtoll_l F
+GLIBC_2.40 strtoq F
+GLIBC_2.40 strtoul F
+GLIBC_2.40 strtoul_l F
+GLIBC_2.40 strtoull F
+GLIBC_2.40 strtoull_l F
+GLIBC_2.40 strtoumax F
+GLIBC_2.40 strtouq F
+GLIBC_2.40 strverscmp F
+GLIBC_2.40 strxfrm F
+GLIBC_2.40 strxfrm_l F
+GLIBC_2.40 stty F
+GLIBC_2.40 swab F
+GLIBC_2.40 swapcontext F
+GLIBC_2.40 swprintf F
+GLIBC_2.40 swscanf F
+GLIBC_2.40 swtch F
+GLIBC_2.40 swtch_pri F
+GLIBC_2.40 symlink F
+GLIBC_2.40 symlinkat F
+GLIBC_2.40 sync F
+GLIBC_2.40 syncfs F
+GLIBC_2.40 syscall F
+GLIBC_2.40 sysconf F
+GLIBC_2.40 syslog F
+GLIBC_2.40 system F
+GLIBC_2.40 sysv_signal F
+GLIBC_2.40 task2pid F
+GLIBC_2.40 task_create F
+GLIBC_2.40 task_set_special_port F
+GLIBC_2.40 task_suspend F
+GLIBC_2.40 task_terminate F
+GLIBC_2.40 tcdrain F
+GLIBC_2.40 tcflow F
+GLIBC_2.40 tcflush F
+GLIBC_2.40 tcgetattr F
+GLIBC_2.40 tcgetpgrp F
+GLIBC_2.40 tcgetsid F
+GLIBC_2.40 tcsendbreak F
+GLIBC_2.40 tcsetattr F
+GLIBC_2.40 tcsetpgrp F
+GLIBC_2.40 tdelete F
+GLIBC_2.40 tdestroy F
+GLIBC_2.40 telldir F
+GLIBC_2.40 tempnam F
+GLIBC_2.40 textdomain F
+GLIBC_2.40 tfind F
+GLIBC_2.40 thrd_current F
+GLIBC_2.40 thrd_equal F
+GLIBC_2.40 thrd_sleep F
+GLIBC_2.40 thrd_yield F
+GLIBC_2.40 thread_depress_abort F
+GLIBC_2.40 thread_switch F
+GLIBC_2.40 time F
+GLIBC_2.40 timegm F
+GLIBC_2.40 timelocal F
+GLIBC_2.40 times F
+GLIBC_2.40 timespec_get F
+GLIBC_2.40 timespec_getres F
+GLIBC_2.40 timezone D 0x8
+GLIBC_2.40 tmpfile F
+GLIBC_2.40 tmpfile64 F
+GLIBC_2.40 tmpnam F
+GLIBC_2.40 tmpnam_r F
+GLIBC_2.40 toascii F
+GLIBC_2.40 tolower F
+GLIBC_2.40 tolower_l F
+GLIBC_2.40 toupper F
+GLIBC_2.40 toupper_l F
+GLIBC_2.40 towctrans F
+GLIBC_2.40 towctrans_l F
+GLIBC_2.40 towlower F
+GLIBC_2.40 towlower_l F
+GLIBC_2.40 towupper F
+GLIBC_2.40 towupper_l F
+GLIBC_2.40 truncate F
+GLIBC_2.40 truncate64 F
+GLIBC_2.40 tsearch F
+GLIBC_2.40 ttyname F
+GLIBC_2.40 ttyname_r F
+GLIBC_2.40 ttyslot F
+GLIBC_2.40 twalk F
+GLIBC_2.40 twalk_r F
+GLIBC_2.40 tzname D 0x10
+GLIBC_2.40 tzset F
+GLIBC_2.40 ualarm F
+GLIBC_2.40 ulckpwdf F
+GLIBC_2.40 ulimit F
+GLIBC_2.40 umask F
+GLIBC_2.40 uname F
+GLIBC_2.40 ungetc F
+GLIBC_2.40 ungetwc F
+GLIBC_2.40 unlink F
+GLIBC_2.40 unlinkat F
+GLIBC_2.40 unlockpt F
+GLIBC_2.40 unsetenv F
+GLIBC_2.40 updwtmp F
+GLIBC_2.40 updwtmpx F
+GLIBC_2.40 uselocale F
+GLIBC_2.40 usleep F
+GLIBC_2.40 utime F
+GLIBC_2.40 utimensat F
+GLIBC_2.40 utimes F
+GLIBC_2.40 utmpname F
+GLIBC_2.40 utmpxname F
+GLIBC_2.40 valloc F
+GLIBC_2.40 vasprintf F
+GLIBC_2.40 vdprintf F
+GLIBC_2.40 verr F
+GLIBC_2.40 verrx F
+GLIBC_2.40 versionsort F
+GLIBC_2.40 versionsort64 F
+GLIBC_2.40 vfork F
+GLIBC_2.40 vfprintf F
+GLIBC_2.40 vfscanf F
+GLIBC_2.40 vfwprintf F
+GLIBC_2.40 vfwscanf F
+GLIBC_2.40 vhangup F
+GLIBC_2.40 vlimit F
+GLIBC_2.40 vm_allocate F
+GLIBC_2.40 vm_deallocate F
+GLIBC_2.40 vm_map F
+GLIBC_2.40 vm_page_size D 0x8
+GLIBC_2.40 vpprintf F
+GLIBC_2.40 vprintf F
+GLIBC_2.40 vscanf F
+GLIBC_2.40 vsnprintf F
+GLIBC_2.40 vsprintf F
+GLIBC_2.40 vsscanf F
+GLIBC_2.40 vswprintf F
+GLIBC_2.40 vswscanf F
+GLIBC_2.40 vsyslog F
+GLIBC_2.40 vwarn F
+GLIBC_2.40 vwarnx F
+GLIBC_2.40 vwprintf F
+GLIBC_2.40 vwscanf F
+GLIBC_2.40 wait F
+GLIBC_2.40 wait3 F
+GLIBC_2.40 wait4 F
+GLIBC_2.40 waitid F
+GLIBC_2.40 waitpid F
+GLIBC_2.40 warn F
+GLIBC_2.40 warnx F
+GLIBC_2.40 wcpcpy F
+GLIBC_2.40 wcpncpy F
+GLIBC_2.40 wcrtomb F
+GLIBC_2.40 wcscasecmp F
+GLIBC_2.40 wcscasecmp_l F
+GLIBC_2.40 wcscat F
+GLIBC_2.40 wcschr F
+GLIBC_2.40 wcschrnul F
+GLIBC_2.40 wcscmp F
+GLIBC_2.40 wcscoll F
+GLIBC_2.40 wcscoll_l F
+GLIBC_2.40 wcscpy F
+GLIBC_2.40 wcscspn F
+GLIBC_2.40 wcsdup F
+GLIBC_2.40 wcsftime F
+GLIBC_2.40 wcsftime_l F
+GLIBC_2.40 wcslcat F
+GLIBC_2.40 wcslcpy F
+GLIBC_2.40 wcslen F
+GLIBC_2.40 wcsncasecmp F
+GLIBC_2.40 wcsncasecmp_l F
+GLIBC_2.40 wcsncat F
+GLIBC_2.40 wcsncmp F
+GLIBC_2.40 wcsncpy F
+GLIBC_2.40 wcsnlen F
+GLIBC_2.40 wcsnrtombs F
+GLIBC_2.40 wcspbrk F
+GLIBC_2.40 wcsrchr F
+GLIBC_2.40 wcsrtombs F
+GLIBC_2.40 wcsspn F
+GLIBC_2.40 wcsstr F
+GLIBC_2.40 wcstod F
+GLIBC_2.40 wcstod_l F
+GLIBC_2.40 wcstof F
+GLIBC_2.40 wcstof128 F
+GLIBC_2.40 wcstof128_l F
+GLIBC_2.40 wcstof32 F
+GLIBC_2.40 wcstof32_l F
+GLIBC_2.40 wcstof32x F
+GLIBC_2.40 wcstof32x_l F
+GLIBC_2.40 wcstof64 F
+GLIBC_2.40 wcstof64_l F
+GLIBC_2.40 wcstof64x F
+GLIBC_2.40 wcstof64x_l F
+GLIBC_2.40 wcstof_l F
+GLIBC_2.40 wcstoimax F
+GLIBC_2.40 wcstok F
+GLIBC_2.40 wcstol F
+GLIBC_2.40 wcstol_l F
+GLIBC_2.40 wcstold F
+GLIBC_2.40 wcstold_l F
+GLIBC_2.40 wcstoll F
+GLIBC_2.40 wcstoll_l F
+GLIBC_2.40 wcstombs F
+GLIBC_2.40 wcstoq F
+GLIBC_2.40 wcstoul F
+GLIBC_2.40 wcstoul_l F
+GLIBC_2.40 wcstoull F
+GLIBC_2.40 wcstoull_l F
+GLIBC_2.40 wcstoumax F
+GLIBC_2.40 wcstouq F
+GLIBC_2.40 wcswcs F
+GLIBC_2.40 wcswidth F
+GLIBC_2.40 wcsxfrm F
+GLIBC_2.40 wcsxfrm_l F
+GLIBC_2.40 wctob F
+GLIBC_2.40 wctomb F
+GLIBC_2.40 wctrans F
+GLIBC_2.40 wctrans_l F
+GLIBC_2.40 wctype F
+GLIBC_2.40 wctype_l F
+GLIBC_2.40 wcwidth F
+GLIBC_2.40 wmemchr F
+GLIBC_2.40 wmemcmp F
+GLIBC_2.40 wmemcpy F
+GLIBC_2.40 wmemmove F
+GLIBC_2.40 wmempcpy F
+GLIBC_2.40 wmemset F
+GLIBC_2.40 wordexp F
+GLIBC_2.40 wordfree F
+GLIBC_2.40 wprintf F
+GLIBC_2.40 write F
+GLIBC_2.40 writev F
+GLIBC_2.40 wscanf F
+HURD_CTHREADS_0.3 __cthread_getspecific F
+HURD_CTHREADS_0.3 __cthread_keycreate F
+HURD_CTHREADS_0.3 __cthread_setspecific F
+HURD_CTHREADS_0.3 __mutex_init F
+HURD_CTHREADS_0.3 __mutex_lock F
+HURD_CTHREADS_0.3 __mutex_lock_solid F
+HURD_CTHREADS_0.3 __mutex_trylock F
+HURD_CTHREADS_0.3 __mutex_unlock F
+HURD_CTHREADS_0.3 __mutex_unlock_solid F
+HURD_CTHREADS_0.3 __spin_lock F
+HURD_CTHREADS_0.3 __spin_lock_init F
+HURD_CTHREADS_0.3 __spin_lock_solid F
+HURD_CTHREADS_0.3 __spin_try_lock F
+HURD_CTHREADS_0.3 __spin_unlock F
diff --git a/sysdeps/mach/hurd/aarch64/libc_malloc_debug.abilist b/sysdeps/mach/hurd/aarch64/libc_malloc_debug.abilist
new file mode 100644
index 00000000..a0850295
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/libc_malloc_debug.abilist
@@ -0,0 +1,26 @@
+GLIBC_2.40 __free_hook D 0x8
+GLIBC_2.40 __malloc_hook D 0x8
+GLIBC_2.40 __memalign_hook D 0x8
+GLIBC_2.40 __realloc_hook D 0x8
+GLIBC_2.40 aligned_alloc F
+GLIBC_2.40 calloc F
+GLIBC_2.40 free F
+GLIBC_2.40 mallinfo F
+GLIBC_2.40 mallinfo2 F
+GLIBC_2.40 malloc F
+GLIBC_2.40 malloc_info F
+GLIBC_2.40 malloc_stats F
+GLIBC_2.40 malloc_trim F
+GLIBC_2.40 malloc_usable_size F
+GLIBC_2.40 mallopt F
+GLIBC_2.40 mcheck F
+GLIBC_2.40 mcheck_check_all F
+GLIBC_2.40 mcheck_pedantic F
+GLIBC_2.40 memalign F
+GLIBC_2.40 mprobe F
+GLIBC_2.40 mtrace F
+GLIBC_2.40 muntrace F
+GLIBC_2.40 posix_memalign F
+GLIBC_2.40 pvalloc F
+GLIBC_2.40 realloc F
+GLIBC_2.40 valloc F
diff --git a/sysdeps/mach/hurd/aarch64/libdl.abilist b/sysdeps/mach/hurd/aarch64/libdl.abilist
new file mode 100644
index 00000000..e69de29b
diff --git a/sysdeps/mach/hurd/aarch64/libm.abilist b/sysdeps/mach/hurd/aarch64/libm.abilist
new file mode 100644
index 00000000..0e58db87
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/libm.abilist
@@ -0,0 +1,1030 @@
+GLIBC_2.40 __clog10 F
+GLIBC_2.40 __clog10f F
+GLIBC_2.40 __clog10l F
+GLIBC_2.40 __finite F
+GLIBC_2.40 __finitef F
+GLIBC_2.40 __finitel F
+GLIBC_2.40 __fpclassify F
+GLIBC_2.40 __fpclassifyf F
+GLIBC_2.40 __fpclassifyl F
+GLIBC_2.40 __iseqsig F
+GLIBC_2.40 __iseqsigf F
+GLIBC_2.40 __iseqsigl F
+GLIBC_2.40 __issignaling F
+GLIBC_2.40 __issignalingf F
+GLIBC_2.40 __issignalingl F
+GLIBC_2.40 __signbit F
+GLIBC_2.40 __signbitf F
+GLIBC_2.40 __signbitl F
+GLIBC_2.40 __signgam D 0x4
+GLIBC_2.40 acos F
+GLIBC_2.40 acosf F
+GLIBC_2.40 acosf128 F
+GLIBC_2.40 acosf32 F
+GLIBC_2.40 acosf32x F
+GLIBC_2.40 acosf64 F
+GLIBC_2.40 acosf64x F
+GLIBC_2.40 acosh F
+GLIBC_2.40 acoshf F
+GLIBC_2.40 acoshf128 F
+GLIBC_2.40 acoshf32 F
+GLIBC_2.40 acoshf32x F
+GLIBC_2.40 acoshf64 F
+GLIBC_2.40 acoshf64x F
+GLIBC_2.40 acoshl F
+GLIBC_2.40 acosl F
+GLIBC_2.40 asin F
+GLIBC_2.40 asinf F
+GLIBC_2.40 asinf128 F
+GLIBC_2.40 asinf32 F
+GLIBC_2.40 asinf32x F
+GLIBC_2.40 asinf64 F
+GLIBC_2.40 asinf64x F
+GLIBC_2.40 asinh F
+GLIBC_2.40 asinhf F
+GLIBC_2.40 asinhf128 F
+GLIBC_2.40 asinhf32 F
+GLIBC_2.40 asinhf32x F
+GLIBC_2.40 asinhf64 F
+GLIBC_2.40 asinhf64x F
+GLIBC_2.40 asinhl F
+GLIBC_2.40 asinl F
+GLIBC_2.40 atan F
+GLIBC_2.40 atan2 F
+GLIBC_2.40 atan2f F
+GLIBC_2.40 atan2f128 F
+GLIBC_2.40 atan2f32 F
+GLIBC_2.40 atan2f32x F
+GLIBC_2.40 atan2f64 F
+GLIBC_2.40 atan2f64x F
+GLIBC_2.40 atan2l F
+GLIBC_2.40 atanf F
+GLIBC_2.40 atanf128 F
+GLIBC_2.40 atanf32 F
+GLIBC_2.40 atanf32x F
+GLIBC_2.40 atanf64 F
+GLIBC_2.40 atanf64x F
+GLIBC_2.40 atanh F
+GLIBC_2.40 atanhf F
+GLIBC_2.40 atanhf128 F
+GLIBC_2.40 atanhf32 F
+GLIBC_2.40 atanhf32x F
+GLIBC_2.40 atanhf64 F
+GLIBC_2.40 atanhf64x F
+GLIBC_2.40 atanhl F
+GLIBC_2.40 atanl F
+GLIBC_2.40 cabs F
+GLIBC_2.40 cabsf F
+GLIBC_2.40 cabsf128 F
+GLIBC_2.40 cabsf32 F
+GLIBC_2.40 cabsf32x F
+GLIBC_2.40 cabsf64 F
+GLIBC_2.40 cabsf64x F
+GLIBC_2.40 cabsl F
+GLIBC_2.40 cacos F
+GLIBC_2.40 cacosf F
+GLIBC_2.40 cacosf128 F
+GLIBC_2.40 cacosf32 F
+GLIBC_2.40 cacosf32x F
+GLIBC_2.40 cacosf64 F
+GLIBC_2.40 cacosf64x F
+GLIBC_2.40 cacosh F
+GLIBC_2.40 cacoshf F
+GLIBC_2.40 cacoshf128 F
+GLIBC_2.40 cacoshf32 F
+GLIBC_2.40 cacoshf32x F
+GLIBC_2.40 cacoshf64 F
+GLIBC_2.40 cacoshf64x F
+GLIBC_2.40 cacoshl F
+GLIBC_2.40 cacosl F
+GLIBC_2.40 canonicalize F
+GLIBC_2.40 canonicalizef F
+GLIBC_2.40 canonicalizef128 F
+GLIBC_2.40 canonicalizef32 F
+GLIBC_2.40 canonicalizef32x F
+GLIBC_2.40 canonicalizef64 F
+GLIBC_2.40 canonicalizef64x F
+GLIBC_2.40 canonicalizel F
+GLIBC_2.40 carg F
+GLIBC_2.40 cargf F
+GLIBC_2.40 cargf128 F
+GLIBC_2.40 cargf32 F
+GLIBC_2.40 cargf32x F
+GLIBC_2.40 cargf64 F
+GLIBC_2.40 cargf64x F
+GLIBC_2.40 cargl F
+GLIBC_2.40 casin F
+GLIBC_2.40 casinf F
+GLIBC_2.40 casinf128 F
+GLIBC_2.40 casinf32 F
+GLIBC_2.40 casinf32x F
+GLIBC_2.40 casinf64 F
+GLIBC_2.40 casinf64x F
+GLIBC_2.40 casinh F
+GLIBC_2.40 casinhf F
+GLIBC_2.40 casinhf128 F
+GLIBC_2.40 casinhf32 F
+GLIBC_2.40 casinhf32x F
+GLIBC_2.40 casinhf64 F
+GLIBC_2.40 casinhf64x F
+GLIBC_2.40 casinhl F
+GLIBC_2.40 casinl F
+GLIBC_2.40 catan F
+GLIBC_2.40 catanf F
+GLIBC_2.40 catanf128 F
+GLIBC_2.40 catanf32 F
+GLIBC_2.40 catanf32x F
+GLIBC_2.40 catanf64 F
+GLIBC_2.40 catanf64x F
+GLIBC_2.40 catanh F
+GLIBC_2.40 catanhf F
+GLIBC_2.40 catanhf128 F
+GLIBC_2.40 catanhf32 F
+GLIBC_2.40 catanhf32x F
+GLIBC_2.40 catanhf64 F
+GLIBC_2.40 catanhf64x F
+GLIBC_2.40 catanhl F
+GLIBC_2.40 catanl F
+GLIBC_2.40 cbrt F
+GLIBC_2.40 cbrtf F
+GLIBC_2.40 cbrtf128 F
+GLIBC_2.40 cbrtf32 F
+GLIBC_2.40 cbrtf32x F
+GLIBC_2.40 cbrtf64 F
+GLIBC_2.40 cbrtf64x F
+GLIBC_2.40 cbrtl F
+GLIBC_2.40 ccos F
+GLIBC_2.40 ccosf F
+GLIBC_2.40 ccosf128 F
+GLIBC_2.40 ccosf32 F
+GLIBC_2.40 ccosf32x F
+GLIBC_2.40 ccosf64 F
+GLIBC_2.40 ccosf64x F
+GLIBC_2.40 ccosh F
+GLIBC_2.40 ccoshf F
+GLIBC_2.40 ccoshf128 F
+GLIBC_2.40 ccoshf32 F
+GLIBC_2.40 ccoshf32x F
+GLIBC_2.40 ccoshf64 F
+GLIBC_2.40 ccoshf64x F
+GLIBC_2.40 ccoshl F
+GLIBC_2.40 ccosl F
+GLIBC_2.40 ceil F
+GLIBC_2.40 ceilf F
+GLIBC_2.40 ceilf128 F
+GLIBC_2.40 ceilf32 F
+GLIBC_2.40 ceilf32x F
+GLIBC_2.40 ceilf64 F
+GLIBC_2.40 ceilf64x F
+GLIBC_2.40 ceill F
+GLIBC_2.40 cexp F
+GLIBC_2.40 cexpf F
+GLIBC_2.40 cexpf128 F
+GLIBC_2.40 cexpf32 F
+GLIBC_2.40 cexpf32x F
+GLIBC_2.40 cexpf64 F
+GLIBC_2.40 cexpf64x F
+GLIBC_2.40 cexpl F
+GLIBC_2.40 cimag F
+GLIBC_2.40 cimagf F
+GLIBC_2.40 cimagf128 F
+GLIBC_2.40 cimagf32 F
+GLIBC_2.40 cimagf32x F
+GLIBC_2.40 cimagf64 F
+GLIBC_2.40 cimagf64x F
+GLIBC_2.40 cimagl F
+GLIBC_2.40 clog F
+GLIBC_2.40 clog10 F
+GLIBC_2.40 clog10f F
+GLIBC_2.40 clog10f128 F
+GLIBC_2.40 clog10f32 F
+GLIBC_2.40 clog10f32x F
+GLIBC_2.40 clog10f64 F
+GLIBC_2.40 clog10f64x F
+GLIBC_2.40 clog10l F
+GLIBC_2.40 clogf F
+GLIBC_2.40 clogf128 F
+GLIBC_2.40 clogf32 F
+GLIBC_2.40 clogf32x F
+GLIBC_2.40 clogf64 F
+GLIBC_2.40 clogf64x F
+GLIBC_2.40 clogl F
+GLIBC_2.40 conj F
+GLIBC_2.40 conjf F
+GLIBC_2.40 conjf128 F
+GLIBC_2.40 conjf32 F
+GLIBC_2.40 conjf32x F
+GLIBC_2.40 conjf64 F
+GLIBC_2.40 conjf64x F
+GLIBC_2.40 conjl F
+GLIBC_2.40 copysign F
+GLIBC_2.40 copysignf F
+GLIBC_2.40 copysignf128 F
+GLIBC_2.40 copysignf32 F
+GLIBC_2.40 copysignf32x F
+GLIBC_2.40 copysignf64 F
+GLIBC_2.40 copysignf64x F
+GLIBC_2.40 copysignl F
+GLIBC_2.40 cos F
+GLIBC_2.40 cosf F
+GLIBC_2.40 cosf128 F
+GLIBC_2.40 cosf32 F
+GLIBC_2.40 cosf32x F
+GLIBC_2.40 cosf64 F
+GLIBC_2.40 cosf64x F
+GLIBC_2.40 cosh F
+GLIBC_2.40 coshf F
+GLIBC_2.40 coshf128 F
+GLIBC_2.40 coshf32 F
+GLIBC_2.40 coshf32x F
+GLIBC_2.40 coshf64 F
+GLIBC_2.40 coshf64x F
+GLIBC_2.40 coshl F
+GLIBC_2.40 cosl F
+GLIBC_2.40 cpow F
+GLIBC_2.40 cpowf F
+GLIBC_2.40 cpowf128 F
+GLIBC_2.40 cpowf32 F
+GLIBC_2.40 cpowf32x F
+GLIBC_2.40 cpowf64 F
+GLIBC_2.40 cpowf64x F
+GLIBC_2.40 cpowl F
+GLIBC_2.40 cproj F
+GLIBC_2.40 cprojf F
+GLIBC_2.40 cprojf128 F
+GLIBC_2.40 cprojf32 F
+GLIBC_2.40 cprojf32x F
+GLIBC_2.40 cprojf64 F
+GLIBC_2.40 cprojf64x F
+GLIBC_2.40 cprojl F
+GLIBC_2.40 creal F
+GLIBC_2.40 crealf F
+GLIBC_2.40 crealf128 F
+GLIBC_2.40 crealf32 F
+GLIBC_2.40 crealf32x F
+GLIBC_2.40 crealf64 F
+GLIBC_2.40 crealf64x F
+GLIBC_2.40 creall F
+GLIBC_2.40 csin F
+GLIBC_2.40 csinf F
+GLIBC_2.40 csinf128 F
+GLIBC_2.40 csinf32 F
+GLIBC_2.40 csinf32x F
+GLIBC_2.40 csinf64 F
+GLIBC_2.40 csinf64x F
+GLIBC_2.40 csinh F
+GLIBC_2.40 csinhf F
+GLIBC_2.40 csinhf128 F
+GLIBC_2.40 csinhf32 F
+GLIBC_2.40 csinhf32x F
+GLIBC_2.40 csinhf64 F
+GLIBC_2.40 csinhf64x F
+GLIBC_2.40 csinhl F
+GLIBC_2.40 csinl F
+GLIBC_2.40 csqrt F
+GLIBC_2.40 csqrtf F
+GLIBC_2.40 csqrtf128 F
+GLIBC_2.40 csqrtf32 F
+GLIBC_2.40 csqrtf32x F
+GLIBC_2.40 csqrtf64 F
+GLIBC_2.40 csqrtf64x F
+GLIBC_2.40 csqrtl F
+GLIBC_2.40 ctan F
+GLIBC_2.40 ctanf F
+GLIBC_2.40 ctanf128 F
+GLIBC_2.40 ctanf32 F
+GLIBC_2.40 ctanf32x F
+GLIBC_2.40 ctanf64 F
+GLIBC_2.40 ctanf64x F
+GLIBC_2.40 ctanh F
+GLIBC_2.40 ctanhf F
+GLIBC_2.40 ctanhf128 F
+GLIBC_2.40 ctanhf32 F
+GLIBC_2.40 ctanhf32x F
+GLIBC_2.40 ctanhf64 F
+GLIBC_2.40 ctanhf64x F
+GLIBC_2.40 ctanhl F
+GLIBC_2.40 ctanl F
+GLIBC_2.40 daddl F
+GLIBC_2.40 ddivl F
+GLIBC_2.40 dfmal F
+GLIBC_2.40 dmull F
+GLIBC_2.40 drem F
+GLIBC_2.40 dremf F
+GLIBC_2.40 dreml F
+GLIBC_2.40 dsqrtl F
+GLIBC_2.40 dsubl F
+GLIBC_2.40 erf F
+GLIBC_2.40 erfc F
+GLIBC_2.40 erfcf F
+GLIBC_2.40 erfcf128 F
+GLIBC_2.40 erfcf32 F
+GLIBC_2.40 erfcf32x F
+GLIBC_2.40 erfcf64 F
+GLIBC_2.40 erfcf64x F
+GLIBC_2.40 erfcl F
+GLIBC_2.40 erff F
+GLIBC_2.40 erff128 F
+GLIBC_2.40 erff32 F
+GLIBC_2.40 erff32x F
+GLIBC_2.40 erff64 F
+GLIBC_2.40 erff64x F
+GLIBC_2.40 erfl F
+GLIBC_2.40 exp F
+GLIBC_2.40 exp10 F
+GLIBC_2.40 exp10f F
+GLIBC_2.40 exp10f128 F
+GLIBC_2.40 exp10f32 F
+GLIBC_2.40 exp10f32x F
+GLIBC_2.40 exp10f64 F
+GLIBC_2.40 exp10f64x F
+GLIBC_2.40 exp10l F
+GLIBC_2.40 exp2 F
+GLIBC_2.40 exp2f F
+GLIBC_2.40 exp2f128 F
+GLIBC_2.40 exp2f32 F
+GLIBC_2.40 exp2f32x F
+GLIBC_2.40 exp2f64 F
+GLIBC_2.40 exp2f64x F
+GLIBC_2.40 exp2l F
+GLIBC_2.40 expf F
+GLIBC_2.40 expf128 F
+GLIBC_2.40 expf32 F
+GLIBC_2.40 expf32x F
+GLIBC_2.40 expf64 F
+GLIBC_2.40 expf64x F
+GLIBC_2.40 expl F
+GLIBC_2.40 expm1 F
+GLIBC_2.40 expm1f F
+GLIBC_2.40 expm1f128 F
+GLIBC_2.40 expm1f32 F
+GLIBC_2.40 expm1f32x F
+GLIBC_2.40 expm1f64 F
+GLIBC_2.40 expm1f64x F
+GLIBC_2.40 expm1l F
+GLIBC_2.40 f32addf128 F
+GLIBC_2.40 f32addf32x F
+GLIBC_2.40 f32addf64 F
+GLIBC_2.40 f32addf64x F
+GLIBC_2.40 f32divf128 F
+GLIBC_2.40 f32divf32x F
+GLIBC_2.40 f32divf64 F
+GLIBC_2.40 f32divf64x F
+GLIBC_2.40 f32fmaf128 F
+GLIBC_2.40 f32fmaf32x F
+GLIBC_2.40 f32fmaf64 F
+GLIBC_2.40 f32fmaf64x F
+GLIBC_2.40 f32mulf128 F
+GLIBC_2.40 f32mulf32x F
+GLIBC_2.40 f32mulf64 F
+GLIBC_2.40 f32mulf64x F
+GLIBC_2.40 f32sqrtf128 F
+GLIBC_2.40 f32sqrtf32x F
+GLIBC_2.40 f32sqrtf64 F
+GLIBC_2.40 f32sqrtf64x F
+GLIBC_2.40 f32subf128 F
+GLIBC_2.40 f32subf32x F
+GLIBC_2.40 f32subf64 F
+GLIBC_2.40 f32subf64x F
+GLIBC_2.40 f32xaddf128 F
+GLIBC_2.40 f32xaddf64 F
+GLIBC_2.40 f32xaddf64x F
+GLIBC_2.40 f32xdivf128 F
+GLIBC_2.40 f32xdivf64 F
+GLIBC_2.40 f32xdivf64x F
+GLIBC_2.40 f32xfmaf128 F
+GLIBC_2.40 f32xfmaf64 F
+GLIBC_2.40 f32xfmaf64x F
+GLIBC_2.40 f32xmulf128 F
+GLIBC_2.40 f32xmulf64 F
+GLIBC_2.40 f32xmulf64x F
+GLIBC_2.40 f32xsqrtf128 F
+GLIBC_2.40 f32xsqrtf64 F
+GLIBC_2.40 f32xsqrtf64x F
+GLIBC_2.40 f32xsubf128 F
+GLIBC_2.40 f32xsubf64 F
+GLIBC_2.40 f32xsubf64x F
+GLIBC_2.40 f64addf128 F
+GLIBC_2.40 f64addf64x F
+GLIBC_2.40 f64divf128 F
+GLIBC_2.40 f64divf64x F
+GLIBC_2.40 f64fmaf128 F
+GLIBC_2.40 f64fmaf64x F
+GLIBC_2.40 f64mulf128 F
+GLIBC_2.40 f64mulf64x F
+GLIBC_2.40 f64sqrtf128 F
+GLIBC_2.40 f64sqrtf64x F
+GLIBC_2.40 f64subf128 F
+GLIBC_2.40 f64subf64x F
+GLIBC_2.40 f64xaddf128 F
+GLIBC_2.40 f64xdivf128 F
+GLIBC_2.40 f64xfmaf128 F
+GLIBC_2.40 f64xmulf128 F
+GLIBC_2.40 f64xsqrtf128 F
+GLIBC_2.40 f64xsubf128 F
+GLIBC_2.40 fabs F
+GLIBC_2.40 fabsf F
+GLIBC_2.40 fabsf128 F
+GLIBC_2.40 fabsf32 F
+GLIBC_2.40 fabsf32x F
+GLIBC_2.40 fabsf64 F
+GLIBC_2.40 fabsf64x F
+GLIBC_2.40 fabsl F
+GLIBC_2.40 fadd F
+GLIBC_2.40 faddl F
+GLIBC_2.40 fdim F
+GLIBC_2.40 fdimf F
+GLIBC_2.40 fdimf128 F
+GLIBC_2.40 fdimf32 F
+GLIBC_2.40 fdimf32x F
+GLIBC_2.40 fdimf64 F
+GLIBC_2.40 fdimf64x F
+GLIBC_2.40 fdiml F
+GLIBC_2.40 fdiv F
+GLIBC_2.40 fdivl F
+GLIBC_2.40 feclearexcept F
+GLIBC_2.40 fedisableexcept F
+GLIBC_2.40 feenableexcept F
+GLIBC_2.40 fegetenv F
+GLIBC_2.40 fegetexcept F
+GLIBC_2.40 fegetexceptflag F
+GLIBC_2.40 fegetmode F
+GLIBC_2.40 fegetround F
+GLIBC_2.40 feholdexcept F
+GLIBC_2.40 feraiseexcept F
+GLIBC_2.40 fesetenv F
+GLIBC_2.40 fesetexcept F
+GLIBC_2.40 fesetexceptflag F
+GLIBC_2.40 fesetmode F
+GLIBC_2.40 fesetround F
+GLIBC_2.40 fetestexcept F
+GLIBC_2.40 fetestexceptflag F
+GLIBC_2.40 feupdateenv F
+GLIBC_2.40 ffma F
+GLIBC_2.40 ffmal F
+GLIBC_2.40 finite F
+GLIBC_2.40 finitef F
+GLIBC_2.40 finitel F
+GLIBC_2.40 floor F
+GLIBC_2.40 floorf F
+GLIBC_2.40 floorf128 F
+GLIBC_2.40 floorf32 F
+GLIBC_2.40 floorf32x F
+GLIBC_2.40 floorf64 F
+GLIBC_2.40 floorf64x F
+GLIBC_2.40 floorl F
+GLIBC_2.40 fma F
+GLIBC_2.40 fmaf F
+GLIBC_2.40 fmaf128 F
+GLIBC_2.40 fmaf32 F
+GLIBC_2.40 fmaf32x F
+GLIBC_2.40 fmaf64 F
+GLIBC_2.40 fmaf64x F
+GLIBC_2.40 fmal F
+GLIBC_2.40 fmax F
+GLIBC_2.40 fmaxf F
+GLIBC_2.40 fmaxf128 F
+GLIBC_2.40 fmaxf32 F
+GLIBC_2.40 fmaxf32x F
+GLIBC_2.40 fmaxf64 F
+GLIBC_2.40 fmaxf64x F
+GLIBC_2.40 fmaximum F
+GLIBC_2.40 fmaximum_mag F
+GLIBC_2.40 fmaximum_mag_num F
+GLIBC_2.40 fmaximum_mag_numf F
+GLIBC_2.40 fmaximum_mag_numf128 F
+GLIBC_2.40 fmaximum_mag_numf32 F
+GLIBC_2.40 fmaximum_mag_numf32x F
+GLIBC_2.40 fmaximum_mag_numf64 F
+GLIBC_2.40 fmaximum_mag_numf64x F
+GLIBC_2.40 fmaximum_mag_numl F
+GLIBC_2.40 fmaximum_magf F
+GLIBC_2.40 fmaximum_magf128 F
+GLIBC_2.40 fmaximum_magf32 F
+GLIBC_2.40 fmaximum_magf32x F
+GLIBC_2.40 fmaximum_magf64 F
+GLIBC_2.40 fmaximum_magf64x F
+GLIBC_2.40 fmaximum_magl F
+GLIBC_2.40 fmaximum_num F
+GLIBC_2.40 fmaximum_numf F
+GLIBC_2.40 fmaximum_numf128 F
+GLIBC_2.40 fmaximum_numf32 F
+GLIBC_2.40 fmaximum_numf32x F
+GLIBC_2.40 fmaximum_numf64 F
+GLIBC_2.40 fmaximum_numf64x F
+GLIBC_2.40 fmaximum_numl F
+GLIBC_2.40 fmaximumf F
+GLIBC_2.40 fmaximumf128 F
+GLIBC_2.40 fmaximumf32 F
+GLIBC_2.40 fmaximumf32x F
+GLIBC_2.40 fmaximumf64 F
+GLIBC_2.40 fmaximumf64x F
+GLIBC_2.40 fmaximuml F
+GLIBC_2.40 fmaxl F
+GLIBC_2.40 fmaxmag F
+GLIBC_2.40 fmaxmagf F
+GLIBC_2.40 fmaxmagf128 F
+GLIBC_2.40 fmaxmagf32 F
+GLIBC_2.40 fmaxmagf32x F
+GLIBC_2.40 fmaxmagf64 F
+GLIBC_2.40 fmaxmagf64x F
+GLIBC_2.40 fmaxmagl F
+GLIBC_2.40 fmin F
+GLIBC_2.40 fminf F
+GLIBC_2.40 fminf128 F
+GLIBC_2.40 fminf32 F
+GLIBC_2.40 fminf32x F
+GLIBC_2.40 fminf64 F
+GLIBC_2.40 fminf64x F
+GLIBC_2.40 fminimum F
+GLIBC_2.40 fminimum_mag F
+GLIBC_2.40 fminimum_mag_num F
+GLIBC_2.40 fminimum_mag_numf F
+GLIBC_2.40 fminimum_mag_numf128 F
+GLIBC_2.40 fminimum_mag_numf32 F
+GLIBC_2.40 fminimum_mag_numf32x F
+GLIBC_2.40 fminimum_mag_numf64 F
+GLIBC_2.40 fminimum_mag_numf64x F
+GLIBC_2.40 fminimum_mag_numl F
+GLIBC_2.40 fminimum_magf F
+GLIBC_2.40 fminimum_magf128 F
+GLIBC_2.40 fminimum_magf32 F
+GLIBC_2.40 fminimum_magf32x F
+GLIBC_2.40 fminimum_magf64 F
+GLIBC_2.40 fminimum_magf64x F
+GLIBC_2.40 fminimum_magl F
+GLIBC_2.40 fminimum_num F
+GLIBC_2.40 fminimum_numf F
+GLIBC_2.40 fminimum_numf128 F
+GLIBC_2.40 fminimum_numf32 F
+GLIBC_2.40 fminimum_numf32x F
+GLIBC_2.40 fminimum_numf64 F
+GLIBC_2.40 fminimum_numf64x F
+GLIBC_2.40 fminimum_numl F
+GLIBC_2.40 fminimumf F
+GLIBC_2.40 fminimumf128 F
+GLIBC_2.40 fminimumf32 F
+GLIBC_2.40 fminimumf32x F
+GLIBC_2.40 fminimumf64 F
+GLIBC_2.40 fminimumf64x F
+GLIBC_2.40 fminimuml F
+GLIBC_2.40 fminl F
+GLIBC_2.40 fminmag F
+GLIBC_2.40 fminmagf F
+GLIBC_2.40 fminmagf128 F
+GLIBC_2.40 fminmagf32 F
+GLIBC_2.40 fminmagf32x F
+GLIBC_2.40 fminmagf64 F
+GLIBC_2.40 fminmagf64x F
+GLIBC_2.40 fminmagl F
+GLIBC_2.40 fmod F
+GLIBC_2.40 fmodf F
+GLIBC_2.40 fmodf128 F
+GLIBC_2.40 fmodf32 F
+GLIBC_2.40 fmodf32x F
+GLIBC_2.40 fmodf64 F
+GLIBC_2.40 fmodf64x F
+GLIBC_2.40 fmodl F
+GLIBC_2.40 fmul F
+GLIBC_2.40 fmull F
+GLIBC_2.40 frexp F
+GLIBC_2.40 frexpf F
+GLIBC_2.40 frexpf128 F
+GLIBC_2.40 frexpf32 F
+GLIBC_2.40 frexpf32x F
+GLIBC_2.40 frexpf64 F
+GLIBC_2.40 frexpf64x F
+GLIBC_2.40 frexpl F
+GLIBC_2.40 fromfp F
+GLIBC_2.40 fromfpf F
+GLIBC_2.40 fromfpf128 F
+GLIBC_2.40 fromfpf32 F
+GLIBC_2.40 fromfpf32x F
+GLIBC_2.40 fromfpf64 F
+GLIBC_2.40 fromfpf64x F
+GLIBC_2.40 fromfpl F
+GLIBC_2.40 fromfpx F
+GLIBC_2.40 fromfpxf F
+GLIBC_2.40 fromfpxf128 F
+GLIBC_2.40 fromfpxf32 F
+GLIBC_2.40 fromfpxf32x F
+GLIBC_2.40 fromfpxf64 F
+GLIBC_2.40 fromfpxf64x F
+GLIBC_2.40 fromfpxl F
+GLIBC_2.40 fsqrt F
+GLIBC_2.40 fsqrtl F
+GLIBC_2.40 fsub F
+GLIBC_2.40 fsubl F
+GLIBC_2.40 gamma F
+GLIBC_2.40 gammaf F
+GLIBC_2.40 gammal F
+GLIBC_2.40 getpayload F
+GLIBC_2.40 getpayloadf F
+GLIBC_2.40 getpayloadf128 F
+GLIBC_2.40 getpayloadf32 F
+GLIBC_2.40 getpayloadf32x F
+GLIBC_2.40 getpayloadf64 F
+GLIBC_2.40 getpayloadf64x F
+GLIBC_2.40 getpayloadl F
+GLIBC_2.40 hypot F
+GLIBC_2.40 hypotf F
+GLIBC_2.40 hypotf128 F
+GLIBC_2.40 hypotf32 F
+GLIBC_2.40 hypotf32x F
+GLIBC_2.40 hypotf64 F
+GLIBC_2.40 hypotf64x F
+GLIBC_2.40 hypotl F
+GLIBC_2.40 ilogb F
+GLIBC_2.40 ilogbf F
+GLIBC_2.40 ilogbf128 F
+GLIBC_2.40 ilogbf32 F
+GLIBC_2.40 ilogbf32x F
+GLIBC_2.40 ilogbf64 F
+GLIBC_2.40 ilogbf64x F
+GLIBC_2.40 ilogbl F
+GLIBC_2.40 j0 F
+GLIBC_2.40 j0f F
+GLIBC_2.40 j0f128 F
+GLIBC_2.40 j0f32 F
+GLIBC_2.40 j0f32x F
+GLIBC_2.40 j0f64 F
+GLIBC_2.40 j0f64x F
+GLIBC_2.40 j0l F
+GLIBC_2.40 j1 F
+GLIBC_2.40 j1f F
+GLIBC_2.40 j1f128 F
+GLIBC_2.40 j1f32 F
+GLIBC_2.40 j1f32x F
+GLIBC_2.40 j1f64 F
+GLIBC_2.40 j1f64x F
+GLIBC_2.40 j1l F
+GLIBC_2.40 jn F
+GLIBC_2.40 jnf F
+GLIBC_2.40 jnf128 F
+GLIBC_2.40 jnf32 F
+GLIBC_2.40 jnf32x F
+GLIBC_2.40 jnf64 F
+GLIBC_2.40 jnf64x F
+GLIBC_2.40 jnl F
+GLIBC_2.40 ldexp F
+GLIBC_2.40 ldexpf F
+GLIBC_2.40 ldexpf128 F
+GLIBC_2.40 ldexpf32 F
+GLIBC_2.40 ldexpf32x F
+GLIBC_2.40 ldexpf64 F
+GLIBC_2.40 ldexpf64x F
+GLIBC_2.40 ldexpl F
+GLIBC_2.40 lgamma F
+GLIBC_2.40 lgamma_r F
+GLIBC_2.40 lgammaf F
+GLIBC_2.40 lgammaf128 F
+GLIBC_2.40 lgammaf128_r F
+GLIBC_2.40 lgammaf32 F
+GLIBC_2.40 lgammaf32_r F
+GLIBC_2.40 lgammaf32x F
+GLIBC_2.40 lgammaf32x_r F
+GLIBC_2.40 lgammaf64 F
+GLIBC_2.40 lgammaf64_r F
+GLIBC_2.40 lgammaf64x F
+GLIBC_2.40 lgammaf64x_r F
+GLIBC_2.40 lgammaf_r F
+GLIBC_2.40 lgammal F
+GLIBC_2.40 lgammal_r F
+GLIBC_2.40 llogb F
+GLIBC_2.40 llogbf F
+GLIBC_2.40 llogbf128 F
+GLIBC_2.40 llogbf32 F
+GLIBC_2.40 llogbf32x F
+GLIBC_2.40 llogbf64 F
+GLIBC_2.40 llogbf64x F
+GLIBC_2.40 llogbl F
+GLIBC_2.40 llrint F
+GLIBC_2.40 llrintf F
+GLIBC_2.40 llrintf128 F
+GLIBC_2.40 llrintf32 F
+GLIBC_2.40 llrintf32x F
+GLIBC_2.40 llrintf64 F
+GLIBC_2.40 llrintf64x F
+GLIBC_2.40 llrintl F
+GLIBC_2.40 llround F
+GLIBC_2.40 llroundf F
+GLIBC_2.40 llroundf128 F
+GLIBC_2.40 llroundf32 F
+GLIBC_2.40 llroundf32x F
+GLIBC_2.40 llroundf64 F
+GLIBC_2.40 llroundf64x F
+GLIBC_2.40 llroundl F
+GLIBC_2.40 log F
+GLIBC_2.40 log10 F
+GLIBC_2.40 log10f F
+GLIBC_2.40 log10f128 F
+GLIBC_2.40 log10f32 F
+GLIBC_2.40 log10f32x F
+GLIBC_2.40 log10f64 F
+GLIBC_2.40 log10f64x F
+GLIBC_2.40 log10l F
+GLIBC_2.40 log1p F
+GLIBC_2.40 log1pf F
+GLIBC_2.40 log1pf128 F
+GLIBC_2.40 log1pf32 F
+GLIBC_2.40 log1pf32x F
+GLIBC_2.40 log1pf64 F
+GLIBC_2.40 log1pf64x F
+GLIBC_2.40 log1pl F
+GLIBC_2.40 log2 F
+GLIBC_2.40 log2f F
+GLIBC_2.40 log2f128 F
+GLIBC_2.40 log2f32 F
+GLIBC_2.40 log2f32x F
+GLIBC_2.40 log2f64 F
+GLIBC_2.40 log2f64x F
+GLIBC_2.40 log2l F
+GLIBC_2.40 logb F
+GLIBC_2.40 logbf F
+GLIBC_2.40 logbf128 F
+GLIBC_2.40 logbf32 F
+GLIBC_2.40 logbf32x F
+GLIBC_2.40 logbf64 F
+GLIBC_2.40 logbf64x F
+GLIBC_2.40 logbl F
+GLIBC_2.40 logf F
+GLIBC_2.40 logf128 F
+GLIBC_2.40 logf32 F
+GLIBC_2.40 logf32x F
+GLIBC_2.40 logf64 F
+GLIBC_2.40 logf64x F
+GLIBC_2.40 logl F
+GLIBC_2.40 lrint F
+GLIBC_2.40 lrintf F
+GLIBC_2.40 lrintf128 F
+GLIBC_2.40 lrintf32 F
+GLIBC_2.40 lrintf32x F
+GLIBC_2.40 lrintf64 F
+GLIBC_2.40 lrintf64x F
+GLIBC_2.40 lrintl F
+GLIBC_2.40 lround F
+GLIBC_2.40 lroundf F
+GLIBC_2.40 lroundf128 F
+GLIBC_2.40 lroundf32 F
+GLIBC_2.40 lroundf32x F
+GLIBC_2.40 lroundf64 F
+GLIBC_2.40 lroundf64x F
+GLIBC_2.40 lroundl F
+GLIBC_2.40 modf F
+GLIBC_2.40 modff F
+GLIBC_2.40 modff128 F
+GLIBC_2.40 modff32 F
+GLIBC_2.40 modff32x F
+GLIBC_2.40 modff64 F
+GLIBC_2.40 modff64x F
+GLIBC_2.40 modfl F
+GLIBC_2.40 nan F
+GLIBC_2.40 nanf F
+GLIBC_2.40 nanf128 F
+GLIBC_2.40 nanf32 F
+GLIBC_2.40 nanf32x F
+GLIBC_2.40 nanf64 F
+GLIBC_2.40 nanf64x F
+GLIBC_2.40 nanl F
+GLIBC_2.40 nearbyint F
+GLIBC_2.40 nearbyintf F
+GLIBC_2.40 nearbyintf128 F
+GLIBC_2.40 nearbyintf32 F
+GLIBC_2.40 nearbyintf32x F
+GLIBC_2.40 nearbyintf64 F
+GLIBC_2.40 nearbyintf64x F
+GLIBC_2.40 nearbyintl F
+GLIBC_2.40 nextafter F
+GLIBC_2.40 nextafterf F
+GLIBC_2.40 nextafterf128 F
+GLIBC_2.40 nextafterf32 F
+GLIBC_2.40 nextafterf32x F
+GLIBC_2.40 nextafterf64 F
+GLIBC_2.40 nextafterf64x F
+GLIBC_2.40 nextafterl F
+GLIBC_2.40 nextdown F
+GLIBC_2.40 nextdownf F
+GLIBC_2.40 nextdownf128 F
+GLIBC_2.40 nextdownf32 F
+GLIBC_2.40 nextdownf32x F
+GLIBC_2.40 nextdownf64 F
+GLIBC_2.40 nextdownf64x F
+GLIBC_2.40 nextdownl F
+GLIBC_2.40 nexttoward F
+GLIBC_2.40 nexttowardf F
+GLIBC_2.40 nexttowardl F
+GLIBC_2.40 nextup F
+GLIBC_2.40 nextupf F
+GLIBC_2.40 nextupf128 F
+GLIBC_2.40 nextupf32 F
+GLIBC_2.40 nextupf32x F
+GLIBC_2.40 nextupf64 F
+GLIBC_2.40 nextupf64x F
+GLIBC_2.40 nextupl F
+GLIBC_2.40 pow F
+GLIBC_2.40 powf F
+GLIBC_2.40 powf128 F
+GLIBC_2.40 powf32 F
+GLIBC_2.40 powf32x F
+GLIBC_2.40 powf64 F
+GLIBC_2.40 powf64x F
+GLIBC_2.40 powl F
+GLIBC_2.40 remainder F
+GLIBC_2.40 remainderf F
+GLIBC_2.40 remainderf128 F
+GLIBC_2.40 remainderf32 F
+GLIBC_2.40 remainderf32x F
+GLIBC_2.40 remainderf64 F
+GLIBC_2.40 remainderf64x F
+GLIBC_2.40 remainderl F
+GLIBC_2.40 remquo F
+GLIBC_2.40 remquof F
+GLIBC_2.40 remquof128 F
+GLIBC_2.40 remquof32 F
+GLIBC_2.40 remquof32x F
+GLIBC_2.40 remquof64 F
+GLIBC_2.40 remquof64x F
+GLIBC_2.40 remquol F
+GLIBC_2.40 rint F
+GLIBC_2.40 rintf F
+GLIBC_2.40 rintf128 F
+GLIBC_2.40 rintf32 F
+GLIBC_2.40 rintf32x F
+GLIBC_2.40 rintf64 F
+GLIBC_2.40 rintf64x F
+GLIBC_2.40 rintl F
+GLIBC_2.40 round F
+GLIBC_2.40 roundeven F
+GLIBC_2.40 roundevenf F
+GLIBC_2.40 roundevenf128 F
+GLIBC_2.40 roundevenf32 F
+GLIBC_2.40 roundevenf32x F
+GLIBC_2.40 roundevenf64 F
+GLIBC_2.40 roundevenf64x F
+GLIBC_2.40 roundevenl F
+GLIBC_2.40 roundf F
+GLIBC_2.40 roundf128 F
+GLIBC_2.40 roundf32 F
+GLIBC_2.40 roundf32x F
+GLIBC_2.40 roundf64 F
+GLIBC_2.40 roundf64x F
+GLIBC_2.40 roundl F
+GLIBC_2.40 scalb F
+GLIBC_2.40 scalbf F
+GLIBC_2.40 scalbl F
+GLIBC_2.40 scalbln F
+GLIBC_2.40 scalblnf F
+GLIBC_2.40 scalblnf128 F
+GLIBC_2.40 scalblnf32 F
+GLIBC_2.40 scalblnf32x F
+GLIBC_2.40 scalblnf64 F
+GLIBC_2.40 scalblnf64x F
+GLIBC_2.40 scalblnl F
+GLIBC_2.40 scalbn F
+GLIBC_2.40 scalbnf F
+GLIBC_2.40 scalbnf128 F
+GLIBC_2.40 scalbnf32 F
+GLIBC_2.40 scalbnf32x F
+GLIBC_2.40 scalbnf64 F
+GLIBC_2.40 scalbnf64x F
+GLIBC_2.40 scalbnl F
+GLIBC_2.40 setpayload F
+GLIBC_2.40 setpayloadf F
+GLIBC_2.40 setpayloadf128 F
+GLIBC_2.40 setpayloadf32 F
+GLIBC_2.40 setpayloadf32x F
+GLIBC_2.40 setpayloadf64 F
+GLIBC_2.40 setpayloadf64x F
+GLIBC_2.40 setpayloadl F
+GLIBC_2.40 setpayloadsig F
+GLIBC_2.40 setpayloadsigf F
+GLIBC_2.40 setpayloadsigf128 F
+GLIBC_2.40 setpayloadsigf32 F
+GLIBC_2.40 setpayloadsigf32x F
+GLIBC_2.40 setpayloadsigf64 F
+GLIBC_2.40 setpayloadsigf64x F
+GLIBC_2.40 setpayloadsigl F
+GLIBC_2.40 signgam D 0x4
+GLIBC_2.40 significand F
+GLIBC_2.40 significandf F
+GLIBC_2.40 significandl F
+GLIBC_2.40 sin F
+GLIBC_2.40 sincos F
+GLIBC_2.40 sincosf F
+GLIBC_2.40 sincosf128 F
+GLIBC_2.40 sincosf32 F
+GLIBC_2.40 sincosf32x F
+GLIBC_2.40 sincosf64 F
+GLIBC_2.40 sincosf64x F
+GLIBC_2.40 sincosl F
+GLIBC_2.40 sinf F
+GLIBC_2.40 sinf128 F
+GLIBC_2.40 sinf32 F
+GLIBC_2.40 sinf32x F
+GLIBC_2.40 sinf64 F
+GLIBC_2.40 sinf64x F
+GLIBC_2.40 sinh F
+GLIBC_2.40 sinhf F
+GLIBC_2.40 sinhf128 F
+GLIBC_2.40 sinhf32 F
+GLIBC_2.40 sinhf32x F
+GLIBC_2.40 sinhf64 F
+GLIBC_2.40 sinhf64x F
+GLIBC_2.40 sinhl F
+GLIBC_2.40 sinl F
+GLIBC_2.40 sqrt F
+GLIBC_2.40 sqrtf F
+GLIBC_2.40 sqrtf128 F
+GLIBC_2.40 sqrtf32 F
+GLIBC_2.40 sqrtf32x F
+GLIBC_2.40 sqrtf64 F
+GLIBC_2.40 sqrtf64x F
+GLIBC_2.40 sqrtl F
+GLIBC_2.40 tan F
+GLIBC_2.40 tanf F
+GLIBC_2.40 tanf128 F
+GLIBC_2.40 tanf32 F
+GLIBC_2.40 tanf32x F
+GLIBC_2.40 tanf64 F
+GLIBC_2.40 tanf64x F
+GLIBC_2.40 tanh F
+GLIBC_2.40 tanhf F
+GLIBC_2.40 tanhf128 F
+GLIBC_2.40 tanhf32 F
+GLIBC_2.40 tanhf32x F
+GLIBC_2.40 tanhf64 F
+GLIBC_2.40 tanhf64x F
+GLIBC_2.40 tanhl F
+GLIBC_2.40 tanl F
+GLIBC_2.40 tgamma F
+GLIBC_2.40 tgammaf F
+GLIBC_2.40 tgammaf128 F
+GLIBC_2.40 tgammaf32 F
+GLIBC_2.40 tgammaf32x F
+GLIBC_2.40 tgammaf64 F
+GLIBC_2.40 tgammaf64x F
+GLIBC_2.40 tgammal F
+GLIBC_2.40 totalorder F
+GLIBC_2.40 totalorderf F
+GLIBC_2.40 totalorderf128 F
+GLIBC_2.40 totalorderf32 F
+GLIBC_2.40 totalorderf32x F
+GLIBC_2.40 totalorderf64 F
+GLIBC_2.40 totalorderf64x F
+GLIBC_2.40 totalorderl F
+GLIBC_2.40 totalordermag F
+GLIBC_2.40 totalordermagf F
+GLIBC_2.40 totalordermagf128 F
+GLIBC_2.40 totalordermagf32 F
+GLIBC_2.40 totalordermagf32x F
+GLIBC_2.40 totalordermagf64 F
+GLIBC_2.40 totalordermagf64x F
+GLIBC_2.40 totalordermagl F
+GLIBC_2.40 trunc F
+GLIBC_2.40 truncf F
+GLIBC_2.40 truncf128 F
+GLIBC_2.40 truncf32 F
+GLIBC_2.40 truncf32x F
+GLIBC_2.40 truncf64 F
+GLIBC_2.40 truncf64x F
+GLIBC_2.40 truncl F
+GLIBC_2.40 ufromfp F
+GLIBC_2.40 ufromfpf F
+GLIBC_2.40 ufromfpf128 F
+GLIBC_2.40 ufromfpf32 F
+GLIBC_2.40 ufromfpf32x F
+GLIBC_2.40 ufromfpf64 F
+GLIBC_2.40 ufromfpf64x F
+GLIBC_2.40 ufromfpl F
+GLIBC_2.40 ufromfpx F
+GLIBC_2.40 ufromfpxf F
+GLIBC_2.40 ufromfpxf128 F
+GLIBC_2.40 ufromfpxf32 F
+GLIBC_2.40 ufromfpxf32x F
+GLIBC_2.40 ufromfpxf64 F
+GLIBC_2.40 ufromfpxf64x F
+GLIBC_2.40 ufromfpxl F
+GLIBC_2.40 y0 F
+GLIBC_2.40 y0f F
+GLIBC_2.40 y0f128 F
+GLIBC_2.40 y0f32 F
+GLIBC_2.40 y0f32x F
+GLIBC_2.40 y0f64 F
+GLIBC_2.40 y0f64x F
+GLIBC_2.40 y0l F
+GLIBC_2.40 y1 F
+GLIBC_2.40 y1f F
+GLIBC_2.40 y1f128 F
+GLIBC_2.40 y1f32 F
+GLIBC_2.40 y1f32x F
+GLIBC_2.40 y1f64 F
+GLIBC_2.40 y1f64x F
+GLIBC_2.40 y1l F
+GLIBC_2.40 yn F
+GLIBC_2.40 ynf F
+GLIBC_2.40 ynf128 F
+GLIBC_2.40 ynf32 F
+GLIBC_2.40 ynf32x F
+GLIBC_2.40 ynf64 F
+GLIBC_2.40 ynf64x F
+GLIBC_2.40 ynl F
diff --git a/sysdeps/mach/hurd/aarch64/libmvec.abilist b/sysdeps/mach/hurd/aarch64/libmvec.abilist
new file mode 100644
index 00000000..70ac03b4
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/libmvec.abilist
@@ -0,0 +1,75 @@
+GLIBC_2.40 _ZGVnN2v_acos F
+GLIBC_2.40 _ZGVnN2v_acosf F
+GLIBC_2.40 _ZGVnN2v_asin F
+GLIBC_2.40 _ZGVnN2v_asinf F
+GLIBC_2.40 _ZGVnN2v_atan F
+GLIBC_2.40 _ZGVnN2v_atanf F
+GLIBC_2.40 _ZGVnN2v_cos F
+GLIBC_2.40 _ZGVnN2v_cosf F
+GLIBC_2.40 _ZGVnN2v_exp F
+GLIBC_2.40 _ZGVnN2v_exp10 F
+GLIBC_2.40 _ZGVnN2v_exp10f F
+GLIBC_2.40 _ZGVnN2v_exp2 F
+GLIBC_2.40 _ZGVnN2v_exp2f F
+GLIBC_2.40 _ZGVnN2v_expf F
+GLIBC_2.40 _ZGVnN2v_expm1 F
+GLIBC_2.40 _ZGVnN2v_expm1f F
+GLIBC_2.40 _ZGVnN2v_log F
+GLIBC_2.40 _ZGVnN2v_log10 F
+GLIBC_2.40 _ZGVnN2v_log10f F
+GLIBC_2.40 _ZGVnN2v_log1p F
+GLIBC_2.40 _ZGVnN2v_log1pf F
+GLIBC_2.40 _ZGVnN2v_log2 F
+GLIBC_2.40 _ZGVnN2v_log2f F
+GLIBC_2.40 _ZGVnN2v_logf F
+GLIBC_2.40 _ZGVnN2v_sin F
+GLIBC_2.40 _ZGVnN2v_sinf F
+GLIBC_2.40 _ZGVnN2v_tan F
+GLIBC_2.40 _ZGVnN2v_tanf F
+GLIBC_2.40 _ZGVnN2vv_atan2 F
+GLIBC_2.40 _ZGVnN2vv_atan2f F
+GLIBC_2.40 _ZGVnN4v_acosf F
+GLIBC_2.40 _ZGVnN4v_asinf F
+GLIBC_2.40 _ZGVnN4v_atanf F
+GLIBC_2.40 _ZGVnN4v_cosf F
+GLIBC_2.40 _ZGVnN4v_exp10f F
+GLIBC_2.40 _ZGVnN4v_exp2f F
+GLIBC_2.40 _ZGVnN4v_expf F
+GLIBC_2.40 _ZGVnN4v_expm1f F
+GLIBC_2.40 _ZGVnN4v_log10f F
+GLIBC_2.40 _ZGVnN4v_log1pf F
+GLIBC_2.40 _ZGVnN4v_log2f F
+GLIBC_2.40 _ZGVnN4v_logf F
+GLIBC_2.40 _ZGVnN4v_sinf F
+GLIBC_2.40 _ZGVnN4v_tanf F
+GLIBC_2.40 _ZGVnN4vv_atan2f F
+GLIBC_2.40 _ZGVsMxv_acos F
+GLIBC_2.40 _ZGVsMxv_acosf F
+GLIBC_2.40 _ZGVsMxv_asin F
+GLIBC_2.40 _ZGVsMxv_asinf F
+GLIBC_2.40 _ZGVsMxv_atan F
+GLIBC_2.40 _ZGVsMxv_atanf F
+GLIBC_2.40 _ZGVsMxv_cos F
+GLIBC_2.40 _ZGVsMxv_cosf F
+GLIBC_2.40 _ZGVsMxv_exp F
+GLIBC_2.40 _ZGVsMxv_exp10 F
+GLIBC_2.40 _ZGVsMxv_exp10f F
+GLIBC_2.40 _ZGVsMxv_exp2 F
+GLIBC_2.40 _ZGVsMxv_exp2f F
+GLIBC_2.40 _ZGVsMxv_expf F
+GLIBC_2.40 _ZGVsMxv_expm1 F
+GLIBC_2.40 _ZGVsMxv_expm1f F
+GLIBC_2.40 _ZGVsMxv_log F
+GLIBC_2.40 _ZGVsMxv_log10 F
+GLIBC_2.40 _ZGVsMxv_log10f F
+GLIBC_2.40 _ZGVsMxv_log1p F
+GLIBC_2.40 _ZGVsMxv_log1pf F
+GLIBC_2.40 _ZGVsMxv_log2 F
+GLIBC_2.40 _ZGVsMxv_log2f F
+GLIBC_2.40 _ZGVsMxv_logf F
+GLIBC_2.40 _ZGVsMxv_sin F
+GLIBC_2.40 _ZGVsMxv_sinf F
+GLIBC_2.40 _ZGVsMxv_tan F
+GLIBC_2.40 _ZGVsMxv_tanf F
+GLIBC_2.40 _ZGVsMxvv_atan2 F
+GLIBC_2.40 _ZGVsMxvv_atan2f F
diff --git a/sysdeps/mach/hurd/aarch64/libpthread.abilist b/sysdeps/mach/hurd/aarch64/libpthread.abilist
new file mode 100644
index 00000000..326428fc
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/libpthread.abilist
@@ -0,0 +1,165 @@
+GLIBC_2.40 _IO_flockfile F
+GLIBC_2.40 _IO_ftrylockfile F
+GLIBC_2.40 _IO_funlockfile F
+GLIBC_2.40 __errno_location F
+GLIBC_2.40 __h_errno_location F
+GLIBC_2.40 __mutex_lock_solid F
+GLIBC_2.40 __mutex_unlock_solid F
+GLIBC_2.40 __pthread_get_cleanup_stack F
+GLIBC_2.40 __pthread_key_create F
+GLIBC_2.40 __pthread_kill F
+GLIBC_2.40 __pthread_mutex_transfer_np F
+GLIBC_2.40 __pthread_spin_destroy F
+GLIBC_2.40 __pthread_spin_init F
+GLIBC_2.40 __pthread_spin_lock F
+GLIBC_2.40 __pthread_spin_trylock F
+GLIBC_2.40 __pthread_spin_unlock F
+GLIBC_2.40 _cthreads_flockfile F
+GLIBC_2.40 _cthreads_ftrylockfile F
+GLIBC_2.40 _cthreads_funlockfile F
+GLIBC_2.40 _pthread_spin_lock F
+GLIBC_2.40 call_once F
+GLIBC_2.40 cnd_broadcast F
+GLIBC_2.40 cnd_destroy F
+GLIBC_2.40 cnd_init F
+GLIBC_2.40 cnd_signal F
+GLIBC_2.40 cnd_timedwait F
+GLIBC_2.40 cnd_wait F
+GLIBC_2.40 cthread_detach F
+GLIBC_2.40 cthread_fork F
+GLIBC_2.40 cthread_getspecific F
+GLIBC_2.40 cthread_keycreate F
+GLIBC_2.40 cthread_setspecific F
+GLIBC_2.40 flockfile F
+GLIBC_2.40 ftrylockfile F
+GLIBC_2.40 funlockfile F
+GLIBC_2.40 mtx_destroy F
+GLIBC_2.40 mtx_init F
+GLIBC_2.40 mtx_lock F
+GLIBC_2.40 mtx_timedlock F
+GLIBC_2.40 mtx_trylock F
+GLIBC_2.40 mtx_unlock F
+GLIBC_2.40 pthread_attr_destroy F
+GLIBC_2.40 pthread_attr_getguardsize F
+GLIBC_2.40 pthread_attr_getscope F
+GLIBC_2.40 pthread_attr_getstack F
+GLIBC_2.40 pthread_attr_getstackaddr F
+GLIBC_2.40 pthread_attr_getstacksize F
+GLIBC_2.40 pthread_attr_init F
+GLIBC_2.40 pthread_attr_setguardsize F
+GLIBC_2.40 pthread_attr_setschedparam F
+GLIBC_2.40 pthread_attr_setscope F
+GLIBC_2.40 pthread_attr_setstack F
+GLIBC_2.40 pthread_attr_setstackaddr F
+GLIBC_2.40 pthread_attr_setstacksize F
+GLIBC_2.40 pthread_barrier_destroy F
+GLIBC_2.40 pthread_barrier_init F
+GLIBC_2.40 pthread_barrier_wait F
+GLIBC_2.40 pthread_barrierattr_destroy F
+GLIBC_2.40 pthread_barrierattr_getpshared F
+GLIBC_2.40 pthread_barrierattr_init F
+GLIBC_2.40 pthread_barrierattr_setpshared F
+GLIBC_2.40 pthread_cancel F
+GLIBC_2.40 pthread_clockjoin_np F
+GLIBC_2.40 pthread_cond_broadcast F
+GLIBC_2.40 pthread_cond_clockwait F
+GLIBC_2.40 pthread_cond_destroy F
+GLIBC_2.40 pthread_cond_init F
+GLIBC_2.40 pthread_cond_signal F
+GLIBC_2.40 pthread_cond_timedwait F
+GLIBC_2.40 pthread_cond_wait F
+GLIBC_2.40 pthread_condattr_destroy F
+GLIBC_2.40 pthread_condattr_getclock F
+GLIBC_2.40 pthread_condattr_getpshared F
+GLIBC_2.40 pthread_condattr_init F
+GLIBC_2.40 pthread_condattr_setclock F
+GLIBC_2.40 pthread_condattr_setpshared F
+GLIBC_2.40 pthread_create F
+GLIBC_2.40 pthread_detach F
+GLIBC_2.40 pthread_exit F
+GLIBC_2.40 pthread_getattr_np F
+GLIBC_2.40 pthread_getconcurrency F
+GLIBC_2.40 pthread_getcpuclockid F
+GLIBC_2.40 pthread_getspecific F
+GLIBC_2.40 pthread_hurd_cond_timedwait_np F
+GLIBC_2.40 pthread_hurd_cond_wait_np F
+GLIBC_2.40 pthread_join F
+GLIBC_2.40 pthread_key_create F
+GLIBC_2.40 pthread_key_delete F
+GLIBC_2.40 pthread_kill F
+GLIBC_2.40 pthread_mutex_clocklock F
+GLIBC_2.40 pthread_mutex_consistent F
+GLIBC_2.40 pthread_mutex_consistent_np F
+GLIBC_2.40 pthread_mutex_destroy F
+GLIBC_2.40 pthread_mutex_getprioceiling F
+GLIBC_2.40 pthread_mutex_init F
+GLIBC_2.40 pthread_mutex_lock F
+GLIBC_2.40 pthread_mutex_setprioceiling F
+GLIBC_2.40 pthread_mutex_timedlock F
+GLIBC_2.40 pthread_mutex_transfer_np F
+GLIBC_2.40 pthread_mutex_trylock F
+GLIBC_2.40 pthread_mutex_unlock F
+GLIBC_2.40 pthread_mutexattr_destroy F
+GLIBC_2.40 pthread_mutexattr_getprioceiling F
+GLIBC_2.40 pthread_mutexattr_getprotocol F
+GLIBC_2.40 pthread_mutexattr_getpshared F
+GLIBC_2.40 pthread_mutexattr_getrobust F
+GLIBC_2.40 pthread_mutexattr_getrobust_np F
+GLIBC_2.40 pthread_mutexattr_gettype F
+GLIBC_2.40 pthread_mutexattr_init F
+GLIBC_2.40 pthread_mutexattr_setprioceiling F
+GLIBC_2.40 pthread_mutexattr_setprotocol F
+GLIBC_2.40 pthread_mutexattr_setpshared F
+GLIBC_2.40 pthread_mutexattr_setrobust F
+GLIBC_2.40 pthread_mutexattr_setrobust_np F
+GLIBC_2.40 pthread_mutexattr_settype F
+GLIBC_2.40 pthread_once F
+GLIBC_2.40 pthread_rwlock_clockrdlock F
+GLIBC_2.40 pthread_rwlock_clockwrlock F
+GLIBC_2.40 pthread_rwlock_destroy F
+GLIBC_2.40 pthread_rwlock_init F
+GLIBC_2.40 pthread_rwlock_rdlock F
+GLIBC_2.40 pthread_rwlock_timedrdlock F
+GLIBC_2.40 pthread_rwlock_timedwrlock F
+GLIBC_2.40 pthread_rwlock_tryrdlock F
+GLIBC_2.40 pthread_rwlock_trywrlock F
+GLIBC_2.40 pthread_rwlock_unlock F
+GLIBC_2.40 pthread_rwlock_wrlock F
+GLIBC_2.40 pthread_rwlockattr_destroy F
+GLIBC_2.40 pthread_rwlockattr_getpshared F
+GLIBC_2.40 pthread_rwlockattr_init F
+GLIBC_2.40 pthread_rwlockattr_setpshared F
+GLIBC_2.40 pthread_setcancelstate F
+GLIBC_2.40 pthread_setcanceltype F
+GLIBC_2.40 pthread_setconcurrency F
+GLIBC_2.40 pthread_setschedprio F
+GLIBC_2.40 pthread_setspecific F
+GLIBC_2.40 pthread_sigmask F
+GLIBC_2.40 pthread_spin_destroy F
+GLIBC_2.40 pthread_spin_init F
+GLIBC_2.40 pthread_spin_lock F
+GLIBC_2.40 pthread_spin_trylock F
+GLIBC_2.40 pthread_spin_unlock F
+GLIBC_2.40 pthread_testcancel F
+GLIBC_2.40 pthread_timedjoin_np F
+GLIBC_2.40 pthread_tryjoin_np F
+GLIBC_2.40 pthread_yield F
+GLIBC_2.40 sem_clockwait F
+GLIBC_2.40 sem_close F
+GLIBC_2.40 sem_destroy F
+GLIBC_2.40 sem_getvalue F
+GLIBC_2.40 sem_init F
+GLIBC_2.40 sem_open F
+GLIBC_2.40 sem_post F
+GLIBC_2.40 sem_timedwait F
+GLIBC_2.40 sem_trywait F
+GLIBC_2.40 sem_unlink F
+GLIBC_2.40 sem_wait F
+GLIBC_2.40 thrd_create F
+GLIBC_2.40 thrd_detach F
+GLIBC_2.40 thrd_exit F
+GLIBC_2.40 thrd_join F
+GLIBC_2.40 tss_create F
+GLIBC_2.40 tss_delete F
+GLIBC_2.40 tss_get F
+GLIBC_2.40 tss_set F
diff --git a/sysdeps/mach/hurd/aarch64/libresolv.abilist b/sysdeps/mach/hurd/aarch64/libresolv.abilist
new file mode 100644
index 00000000..86225345
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/libresolv.abilist
@@ -0,0 +1,55 @@
+GLIBC_2.40 __b64_ntop F
+GLIBC_2.40 __b64_pton F
+GLIBC_2.40 __dn_count_labels F
+GLIBC_2.40 __fp_nquery F
+GLIBC_2.40 __fp_query F
+GLIBC_2.40 __fp_resstat F
+GLIBC_2.40 __hostalias F
+GLIBC_2.40 __loc_aton F
+GLIBC_2.40 __loc_ntoa F
+GLIBC_2.40 __p_cdname F
+GLIBC_2.40 __p_cdnname F
+GLIBC_2.40 __p_class F
+GLIBC_2.40 __p_class_syms D 0xa8
+GLIBC_2.40 __p_fqname F
+GLIBC_2.40 __p_fqnname F
+GLIBC_2.40 __p_option F
+GLIBC_2.40 __p_query F
+GLIBC_2.40 __p_rcode F
+GLIBC_2.40 __p_time F
+GLIBC_2.40 __p_type F
+GLIBC_2.40 __p_type_syms D 0x450
+GLIBC_2.40 __putlong F
+GLIBC_2.40 __putshort F
+GLIBC_2.40 __res_close F
+GLIBC_2.40 __res_hostalias F
+GLIBC_2.40 __res_isourserver F
+GLIBC_2.40 __res_nameinquery F
+GLIBC_2.40 __res_queriesmatch F
+GLIBC_2.40 __sym_ntop F
+GLIBC_2.40 __sym_ntos F
+GLIBC_2.40 __sym_ston F
+GLIBC_2.40 _getlong F
+GLIBC_2.40 _getshort F
+GLIBC_2.40 inet_net_ntop F
+GLIBC_2.40 inet_net_pton F
+GLIBC_2.40 inet_neta F
+GLIBC_2.40 ns_datetosecs F
+GLIBC_2.40 ns_format_ttl F
+GLIBC_2.40 ns_get16 F
+GLIBC_2.40 ns_get32 F
+GLIBC_2.40 ns_initparse F
+GLIBC_2.40 ns_makecanon F
+GLIBC_2.40 ns_msg_getflag F
+GLIBC_2.40 ns_name_ntol F
+GLIBC_2.40 ns_name_rollback F
+GLIBC_2.40 ns_parse_ttl F
+GLIBC_2.40 ns_parserr F
+GLIBC_2.40 ns_put16 F
+GLIBC_2.40 ns_put32 F
+GLIBC_2.40 ns_samedomain F
+GLIBC_2.40 ns_samename F
+GLIBC_2.40 ns_skiprr F
+GLIBC_2.40 ns_sprintrr F
+GLIBC_2.40 ns_sprintrrf F
+GLIBC_2.40 ns_subdomain F
diff --git a/sysdeps/mach/hurd/aarch64/librt.abilist b/sysdeps/mach/hurd/aarch64/librt.abilist
new file mode 100644
index 00000000..8925aca1
--- /dev/null
+++ b/sysdeps/mach/hurd/aarch64/librt.abilist
@@ -0,0 +1,33 @@
+GLIBC_2.40 __mq_open_2 F
+GLIBC_2.40 aio_cancel F
+GLIBC_2.40 aio_cancel64 F
+GLIBC_2.40 aio_error F
+GLIBC_2.40 aio_error64 F
+GLIBC_2.40 aio_fsync F
+GLIBC_2.40 aio_fsync64 F
+GLIBC_2.40 aio_init F
+GLIBC_2.40 aio_read F
+GLIBC_2.40 aio_read64 F
+GLIBC_2.40 aio_return F
+GLIBC_2.40 aio_return64 F
+GLIBC_2.40 aio_suspend F
+GLIBC_2.40 aio_suspend64 F
+GLIBC_2.40 aio_write F
+GLIBC_2.40 aio_write64 F
+GLIBC_2.40 lio_listio F
+GLIBC_2.40 lio_listio64 F
+GLIBC_2.40 mq_close F
+GLIBC_2.40 mq_getattr F
+GLIBC_2.40 mq_notify F
+GLIBC_2.40 mq_open F
+GLIBC_2.40 mq_receive F
+GLIBC_2.40 mq_send F
+GLIBC_2.40 mq_setattr F
+GLIBC_2.40 mq_timedreceive F
+GLIBC_2.40 mq_timedsend F
+GLIBC_2.40 mq_unlink F
+GLIBC_2.40 timer_create F
+GLIBC_2.40 timer_delete F
+GLIBC_2.40 timer_getoverrun F
+GLIBC_2.40 timer_gettime F
+GLIBC_2.40 timer_settime F
-- 
2.44.0

Re: [PATCH v2 00/20] aarch64-gnu port & GNU/Hurd on AArch64 progress

[Samuel Thibault]

Hello,

Sergey Bugaev, le sam. 23 mars 2024 20:32:41 +0300, a ecrit:
> This is v2 of my work on the aarch64-gnu port, aka GNU/Hurd on 64-bit
> ARM. v1 is here [0].

Thanks!

I applied the easy parts: patches 1-6 and 18 for now.

Samuel

Re: [PATCH v2 00/20] aarch64-gnu port & GNU/Hurd on AArch64 progress

[Sergey Bugaev]

Hello,

it looks like most of this series has been filed away as "Failed CI",
but the failures seem related to the CI setup rather than the series
itself: from what I'm seeing in [0] for example, both Linaro CI jobs
failed with

+ local prev_head=96d1b9ac2321b565f340ba8f3674597141e3450d
<snip>
+ git -C glibc pw series apply 32190 -p1
Failed to apply patch:
error: patch failed: hurd/hurd/signal.h:40
error: hurd/hurd/signal.h: patch does not apply
error: patch failed: sysdeps/hurd/include/hurd/signal.h:9
error: sysdeps/hurd/include/hurd/signal.h: patch does not apply
hint: Use 'git am --show-current-patch=diff' to see the failed patch
Applying: hurd: Move internal functions to internal header
Patch failed at 0001 hurd: Move internal functions to internal header

when trying to apply the patch set on top of [1]. But "hurd: Move
internal functions to internal header" has already been pushed as [2],
which is included in [1]; of course it doesn't apply the second time.

[0] https://patchwork.sourceware.org/project/glibc/patch/20240323173301.151066-14-bugaevc@gmail.com/
[1] https://sourceware.org/git/?p=glibc.git;a=shortlog;h=96d1b9ac2321b565f340ba8f3674597141e3450d
[2] https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=7f02511e5b8879430e2b3c51601341d3c0314071

The log does mention "check for already-applied patches", but
apparently that didn't work here.

Sergey

Re: [PATCH v2 00/20] aarch64-gnu port & GNU/Hurd on AArch64 progress

[Maxim Kuvyrkov]

> On Mar 26, 2024, at 12:29, Sergey Bugaev <bugaevc@gmail.com> wrote:
> 
> Hello,
> 
> it looks like most of this series has been filed away as "Failed CI",
> but the failures seem related to the CI setup rather than the series
> itself: from what I'm seeing in [0] for example, both Linaro CI jobs
> failed with
> 
> + local prev_head=96d1b9ac2321b565f340ba8f3674597141e3450d
> <snip>
> + git -C glibc pw series apply 32190 -p1
> Failed to apply patch:
> error: patch failed: hurd/hurd/signal.h:40
> error: hurd/hurd/signal.h: patch does not apply
> error: patch failed: sysdeps/hurd/include/hurd/signal.h:9
> error: sysdeps/hurd/include/hurd/signal.h: patch does not apply
> hint: Use 'git am --show-current-patch=diff' to see the failed patch
> Applying: hurd: Move internal functions to internal header
> Patch failed at 0001 hurd: Move internal functions to internal header
> 
> when trying to apply the patch set on top of [1]. But "hurd: Move
> internal functions to internal header" has already been pushed as [2],
> which is included in [1]; of course it doesn't apply the second time.

Hi Sergey,

Indeed.  This uncovered a corner-case in our scripting that applies patches.

Thanks,

--
Maxim Kuvyrkov
https://www.linaro.org