nptl: Introduce <tcb-access.h> for THREAD_* accessors

These are common between most architectures.  Only the x86 targets
are outliers.

Reviewed-by: Szabolcs Nagy <szabolcs.nagy@arm.com>

diff --git a/sysdeps/aarch64/nptl/tls.h b/sysdeps/aarch64/nptl/tls.h
index 72f22dc..c9ae564 100644 (file)
--- a/sysdeps/aarch64/nptl/tls.h
+++ b/sysdeps/aarch64/nptl/tls.h
@@ -98,15 +98,7 @@ typedef struct
 # define DB_THREAD_SELF \
   CONST_THREAD_AREA (64, sizeof (struct pthread))
 
-/* Access to data in the thread descriptor is easy.  */
-# define THREAD_GETMEM(descr, member) \
-  descr->member
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-# define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* Get and set the global scope generation counter in struct pthread.  */
 # define THREAD_GSCOPE_FLAG_UNUSED 0

diff --git a/sysdeps/alpha/nptl/tls.h b/sysdeps/alpha/nptl/tls.h
index 6328112..eef922f 100644 (file)
--- a/sysdeps/alpha/nptl/tls.h
+++ b/sysdeps/alpha/nptl/tls.h
@@ -92,15 +92,7 @@ typedef struct
 # define DB_THREAD_SELF \
   REGISTER (64, 64, 32 * 8, -sizeof (struct pthread))
 
-/* Access to data in the thread descriptor is easy.  */
-#define THREAD_GETMEM(descr, member) \
-  descr->member
-#define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-#define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-#define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* Get and set the global scope generation counter in struct pthread.  */
 #define THREAD_GSCOPE_FLAG_UNUSED 0

diff --git a/sysdeps/arc/nptl/tls.h b/sysdeps/arc/nptl/tls.h
index e269c0a..f685386 100644 (file)
--- a/sysdeps/arc/nptl/tls.h
+++ b/sysdeps/arc/nptl/tls.h
@@ -100,15 +100,7 @@ typedef struct
 # define DB_THREAD_SELF \
   CONST_THREAD_AREA (32, sizeof (struct pthread))
 
-/* Access to data in the thread descriptor is easy.  */
-# define THREAD_GETMEM(descr, member) \
-  descr->member
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-# define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* Get and set the global scope generation counter in struct pthread.  */
 #define THREAD_GSCOPE_FLAG_UNUSED 0

diff --git a/sysdeps/arm/nptl/tls.h b/sysdeps/arm/nptl/tls.h
index 699c16a..06612b5 100644 (file)
--- a/sysdeps/arm/nptl/tls.h
+++ b/sysdeps/arm/nptl/tls.h
@@ -89,15 +89,7 @@ typedef struct
 # define DB_THREAD_SELF \
   CONST_THREAD_AREA (32, sizeof (struct pthread))
 
-/* Access to data in the thread descriptor is easy.  */
-#define THREAD_GETMEM(descr, member) \
-  descr->member
-#define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-#define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-#define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* Get and set the global scope generation counter in struct pthread.  */
 #define THREAD_GSCOPE_FLAG_UNUSED 0

diff --git a/sysdeps/csky/nptl/tls.h b/sysdeps/csky/nptl/tls.h
index b210dfc..39fd640 100644 (file)
--- a/sysdeps/csky/nptl/tls.h
+++ b/sysdeps/csky/nptl/tls.h
@@ -116,15 +116,7 @@ typedef struct
 # define DB_THREAD_SELF \
   CONST_THREAD_AREA (32, sizeof (struct pthread))
 
-/* Access to data in the thread descriptor is easy.  */
-# define THREAD_GETMEM(descr, member) \
-  descr->member
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-# define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* Get and set the global scope generation counter in struct pthread.  */
 # define THREAD_GSCOPE_FLAG_UNUSED 0

diff --git a/sysdeps/hppa/nptl/tls.h b/sysdeps/hppa/nptl/tls.h
index 55559eb..5f55022 100644 (file)
--- a/sysdeps/hppa/nptl/tls.h
+++ b/sysdeps/hppa/nptl/tls.h
@@ -107,15 +107,7 @@ typedef struct
 # define DB_THREAD_SELF \
   REGISTER (32, 32, 53 * 4, -sizeof (struct pthread))
 
-/* Access to data in the thread descriptor is easy.  */
-# define THREAD_GETMEM(descr, member) \
-  descr->member
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-# define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 static inline struct pthread *__get_cr27(void)
 {

diff --git a/sysdeps/i386/nptl/tcb-access.h b/sysdeps/i386/nptl/tcb-access.h
new file mode 100644 (file)
index 0000000..6c6d561
--- /dev/null
+++ b/sysdeps/i386/nptl/tcb-access.h
@@ -0,0 +1,123 @@
+/* THREAD_* accessors.  i386 version.
+   Copyright (C) 2002-2021 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/>.  */
+
+/* Read member of the thread descriptor directly.  */
+#define THREAD_GETMEM(descr, member) \
+  ({ __typeof (descr->member) __value;                                       \
+     _Static_assert (sizeof (__value) == 1                                   \
+                    || sizeof (__value) == 4                                 \
+                    || sizeof (__value) == 8,                                \
+                    "size of per-thread data");                              \
+     if (sizeof (__value) == 1)                                                      \
+       asm volatile ("movb %%gs:%P2,%b0"                                     \
+                    : "=q" (__value)                                         \
+                    : "0" (0), "i" (offsetof (struct pthread, member)));     \
+     else if (sizeof (__value) == 4)                                         \
+       asm volatile ("movl %%gs:%P1,%0"                                              \
+                    : "=r" (__value)                                         \
+                    : "i" (offsetof (struct pthread, member)));              \
+     else /* 8 */                                                                    \
+       {                                                                     \
+        asm volatile ("movl %%gs:%P1,%%eax\n\t"                              \
+                      "movl %%gs:%P2,%%edx"                                  \
+                      : "=A" (__value)                                       \
+                      : "i" (offsetof (struct pthread, member)),             \
+                        "i" (offsetof (struct pthread, member) + 4));        \
+       }                                                                     \
+     __value; })
+
+
+/* Same as THREAD_GETMEM, but the member offset can be non-constant.  */
+#define THREAD_GETMEM_NC(descr, member, idx) \
+  ({ __typeof (descr->member[0]) __value;                                    \
+     _Static_assert (sizeof (__value) == 1                                   \
+                    || sizeof (__value) == 4                                 \
+                    || sizeof (__value) == 8,                                \
+                    "size of per-thread data");                              \
+     if (sizeof (__value) == 1)                                                      \
+       asm volatile ("movb %%gs:%P2(%3),%b0"                                 \
+                    : "=q" (__value)                                         \
+                    : "0" (0), "i" (offsetof (struct pthread, member[0])),   \
+                    "r" (idx));                                              \
+     else if (sizeof (__value) == 4)                                         \
+       asm volatile ("movl %%gs:%P1(,%2,4),%0"                               \
+                    : "=r" (__value)                                         \
+                    : "i" (offsetof (struct pthread, member[0])),            \
+                      "r" (idx));                                            \
+     else /* 8 */                                                            \
+       {                                                                     \
+        asm volatile  ("movl %%gs:%P1(,%2,8),%%eax\n\t"                      \
+                       "movl %%gs:4+%P1(,%2,8),%%edx"                        \
+                       : "=&A" (__value)                                     \
+                       : "i" (offsetof (struct pthread, member[0])),         \
+                         "r" (idx));                                         \
+       }                                                                     \
+     __value; })
+
+
+
+/* Set member of the thread descriptor directly.  */
+#define THREAD_SETMEM(descr, member, value) \
+  ({                                                                         \
+     _Static_assert (sizeof (descr->member) == 1                             \
+                    || sizeof (descr->member) == 4                           \
+                    || sizeof (descr->member) == 8,                          \
+                    "size of per-thread data");                              \
+     if (sizeof (descr->member) == 1)                                        \
+       asm volatile ("movb %b0,%%gs:%P1" :                                   \
+                    : "iq" (value),                                          \
+                      "i" (offsetof (struct pthread, member)));              \
+     else if (sizeof (descr->member) == 4)                                   \
+       asm volatile ("movl %0,%%gs:%P1" :                                    \
+                    : "ir" (value),                                          \
+                      "i" (offsetof (struct pthread, member)));              \
+     else /* 8 */                                                            \
+       {                                                                     \
+        asm volatile ("movl %%eax,%%gs:%P1\n\t"                              \
+                      "movl %%edx,%%gs:%P2" :                                \
+                      : "A" ((uint64_t) cast_to_integer (value)),            \
+                        "i" (offsetof (struct pthread, member)),             \
+                        "i" (offsetof (struct pthread, member) + 4));        \
+       }})
+
+
+/* Same as THREAD_SETMEM, but the member offset can be non-constant.  */
+#define THREAD_SETMEM_NC(descr, member, idx, value) \
+  ({                                                                         \
+     _Static_assert (sizeof (descr->member[0]) == 1                          \
+                    || sizeof (descr->member[0]) == 4                        \
+                    || sizeof (descr->member[0]) == 8,                       \
+                    "size of per-thread data");                              \
+     if (sizeof (descr->member[0]) == 1)                                     \
+       asm volatile ("movb %b0,%%gs:%P1(%2)" :                               \
+                    : "iq" (value),                                          \
+                      "i" (offsetof (struct pthread, member)),               \
+                      "r" (idx));                                            \
+     else if (sizeof (descr->member[0]) == 4)                                \
+       asm volatile ("movl %0,%%gs:%P1(,%2,4)" :                             \
+                    : "ir" (value),                                          \
+                      "i" (offsetof (struct pthread, member)),               \
+                      "r" (idx));                                            \
+     else /* 8 */                                                            \
+       {                                                                     \
+        asm volatile ("movl %%eax,%%gs:%P1(,%2,8)\n\t"                       \
+                      "movl %%edx,%%gs:4+%P1(,%2,8)" :                       \
+                      : "A" ((uint64_t) cast_to_integer (value)),            \
+                        "i" (offsetof (struct pthread, member)),             \
+                        "r" (idx));                                          \
+       }})

diff --git a/sysdeps/i386/nptl/tls.h b/sysdeps/i386/nptl/tls.h
index cfb27f5..d010e14 100644 (file)
--- a/sysdeps/i386/nptl/tls.h
+++ b/sysdeps/i386/nptl/tls.h
@@ -250,113 +250,7 @@ tls_fill_user_desc (union user_desc_init *desc,
   REGISTER_THREAD_AREA (32, offsetof (struct user_regs_struct, xgs), 3) \
   REGISTER_THREAD_AREA (64, 26 * 8, 3) /* x86-64's user_regs_struct->gs */
 
-
-/* Read member of the thread descriptor directly.  */
-# define THREAD_GETMEM(descr, member) \
-  ({ __typeof (descr->member) __value;                                       \
-     _Static_assert (sizeof (__value) == 1                                   \
-                    || sizeof (__value) == 4                                 \
-                    || sizeof (__value) == 8,                                \
-                    "size of per-thread data");                              \
-     if (sizeof (__value) == 1)                                                      \
-       asm volatile ("movb %%gs:%P2,%b0"                                     \
-                    : "=q" (__value)                                         \
-                    : "0" (0), "i" (offsetof (struct pthread, member)));     \
-     else if (sizeof (__value) == 4)                                         \
-       asm volatile ("movl %%gs:%P1,%0"                                              \
-                    : "=r" (__value)                                         \
-                    : "i" (offsetof (struct pthread, member)));              \
-     else /* 8 */                                                                    \
-       {                                                                     \
-        asm volatile ("movl %%gs:%P1,%%eax\n\t"                              \
-                      "movl %%gs:%P2,%%edx"                                  \
-                      : "=A" (__value)                                       \
-                      : "i" (offsetof (struct pthread, member)),             \
-                        "i" (offsetof (struct pthread, member) + 4));        \
-       }                                                                     \
-     __value; })
-
-
-/* Same as THREAD_GETMEM, but the member offset can be non-constant.  */
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  ({ __typeof (descr->member[0]) __value;                                    \
-     _Static_assert (sizeof (__value) == 1                                   \
-                    || sizeof (__value) == 4                                 \
-                    || sizeof (__value) == 8,                                \
-                    "size of per-thread data");                              \
-     if (sizeof (__value) == 1)                                                      \
-       asm volatile ("movb %%gs:%P2(%3),%b0"                                 \
-                    : "=q" (__value)                                         \
-                    : "0" (0), "i" (offsetof (struct pthread, member[0])),   \
-                    "r" (idx));                                              \
-     else if (sizeof (__value) == 4)                                         \
-       asm volatile ("movl %%gs:%P1(,%2,4),%0"                               \
-                    : "=r" (__value)                                         \
-                    : "i" (offsetof (struct pthread, member[0])),            \
-                      "r" (idx));                                            \
-     else /* 8 */                                                            \
-       {                                                                     \
-        asm volatile  ("movl %%gs:%P1(,%2,8),%%eax\n\t"                      \
-                       "movl %%gs:4+%P1(,%2,8),%%edx"                        \
-                       : "=&A" (__value)                                     \
-                       : "i" (offsetof (struct pthread, member[0])),         \
-                         "r" (idx));                                         \
-       }                                                                     \
-     __value; })
-
-
-
-/* Set member of the thread descriptor directly.  */
-# define THREAD_SETMEM(descr, member, value) \
-  ({                                                                         \
-     _Static_assert (sizeof (descr->member) == 1                             \
-                    || sizeof (descr->member) == 4                           \
-                    || sizeof (descr->member) == 8,                          \
-                    "size of per-thread data");                              \
-     if (sizeof (descr->member) == 1)                                        \
-       asm volatile ("movb %b0,%%gs:%P1" :                                   \
-                    : "iq" (value),                                          \
-                      "i" (offsetof (struct pthread, member)));              \
-     else if (sizeof (descr->member) == 4)                                   \
-       asm volatile ("movl %0,%%gs:%P1" :                                    \
-                    : "ir" (value),                                          \
-                      "i" (offsetof (struct pthread, member)));              \
-     else /* 8 */                                                            \
-       {                                                                     \
-        asm volatile ("movl %%eax,%%gs:%P1\n\t"                              \
-                      "movl %%edx,%%gs:%P2" :                                \
-                      : "A" ((uint64_t) cast_to_integer (value)),            \
-                        "i" (offsetof (struct pthread, member)),             \
-                        "i" (offsetof (struct pthread, member) + 4));        \
-       }})
-
-
-/* Same as THREAD_SETMEM, but the member offset can be non-constant.  */
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  ({                                                                         \
-     _Static_assert (sizeof (descr->member[0]) == 1                          \
-                    || sizeof (descr->member[0]) == 4                        \
-                    || sizeof (descr->member[0]) == 8,                       \
-                    "size of per-thread data");                              \
-     if (sizeof (descr->member[0]) == 1)                                     \
-       asm volatile ("movb %b0,%%gs:%P1(%2)" :                               \
-                    : "iq" (value),                                          \
-                      "i" (offsetof (struct pthread, member)),               \
-                      "r" (idx));                                            \
-     else if (sizeof (descr->member[0]) == 4)                                \
-       asm volatile ("movl %0,%%gs:%P1(,%2,4)" :                             \
-                    : "ir" (value),                                          \
-                      "i" (offsetof (struct pthread, member)),               \
-                      "r" (idx));                                            \
-     else /* 8 */                                                            \
-       {                                                                     \
-        asm volatile ("movl %%eax,%%gs:%P1(,%2,8)\n\t"                       \
-                      "movl %%edx,%%gs:4+%P1(,%2,8)" :                       \
-                      : "A" ((uint64_t) cast_to_integer (value)),            \
-                        "i" (offsetof (struct pthread, member)),             \
-                        "r" (idx));                                          \
-       }})
-
+# include <tcb-access.h>
 
 /* Set the stack guard field in TCB head.  */
 #define THREAD_SET_STACK_GUARD(value) \

diff --git a/sysdeps/ia64/nptl/tls.h b/sysdeps/ia64/nptl/tls.h
index 8c26728..44951da 100644 (file)
--- a/sysdeps/ia64/nptl/tls.h
+++ b/sysdeps/ia64/nptl/tls.h
@@ -128,15 +128,7 @@ register struct pthread *__thread_self __asm__("r13");
 /* Magic for libthread_db to know how to do THREAD_SELF.  */
 # define DB_THREAD_SELF REGISTER (64, 64, 13 * 8, -TLS_PRE_TCB_SIZE)
 
-/* Access to data in the thread descriptor is easy.  */
-#define THREAD_GETMEM(descr, member) \
-  descr->member
-#define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-#define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-#define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* Set the stack guard field in TCB head.  */
 #define THREAD_SET_STACK_GUARD(value) \

diff --git a/sysdeps/m68k/nptl/tls.h b/sysdeps/m68k/nptl/tls.h
index 34906b1..257af6b 100644 (file)
--- a/sysdeps/m68k/nptl/tls.h
+++ b/sysdeps/m68k/nptl/tls.h
@@ -117,15 +117,7 @@ extern void * __m68k_read_tp (void);
 # define DB_THREAD_SELF \
   CONST_THREAD_AREA (32, TLS_TCB_OFFSET + TLS_PRE_TCB_SIZE)
 
-/* Access to data in the thread descriptor is easy.  */
-# define THREAD_GETMEM(descr, member) \
-  descr->member
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-# define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* l_tls_offset == 0 is perfectly valid on M68K, so we have to use some
    different value to mean unset l_tls_offset.  */

diff --git a/sysdeps/microblaze/nptl/tls.h b/sysdeps/microblaze/nptl/tls.h
index 0ca67a7..a31703b 100644 (file)
--- a/sysdeps/microblaze/nptl/tls.h
+++ b/sysdeps/microblaze/nptl/tls.h
@@ -100,20 +100,7 @@ typedef struct
 # define DB_THREAD_SELF \
   CONST_THREAD_AREA (32, sizeof (struct pthread))
 
-/* Read member of the thread descriptor directly.  */
-# define THREAD_GETMEM(descr, member) (descr->member)
-
-/* Same as THREAD_GETMEM, but the member offset can be non-constant.  */
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  (descr->member[idx])
-
-/* Set member of the thread descriptor directly.  */
-# define THREAD_SETMEM(descr, member, value) \
-  (descr->member = (value))
-
-/* Same as THREAD_SETMEM, but the member offset can be non-constant.  */
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  (descr->member[idx] = (value))
+# include <tcb-access.h>
 
 /* Get and set the global scope generation counter in struct pthread.  */
 # define THREAD_GSCOPE_FLAG_UNUSED 0

diff --git a/sysdeps/mips/nptl/tls.h b/sysdeps/mips/nptl/tls.h
index 04e823b..afb8308 100644 (file)
--- a/sysdeps/mips/nptl/tls.h
+++ b/sysdeps/mips/nptl/tls.h
@@ -144,14 +144,7 @@ typedef struct
   CONST_THREAD_AREA (32, TLS_TCB_OFFSET + TLS_PRE_TCB_SIZE)
 
 /* Access to data in the thread descriptor is easy.  */
-# define THREAD_GETMEM(descr, member) \
-  descr->member
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-# define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* l_tls_offset == 0 is perfectly valid on MIPS, so we have to use some
    different value to mean unset l_tls_offset.  */

diff --git a/sysdeps/nios2/nptl/tls.h b/sysdeps/nios2/nptl/tls.h
index fd48413..173c395 100644 (file)
--- a/sysdeps/nios2/nptl/tls.h
+++ b/sysdeps/nios2/nptl/tls.h
@@ -112,15 +112,7 @@ register struct pthread *__thread_self __asm__("r23");
 # define DB_THREAD_SELF \
   REGISTER (32, 32, 23 * 4, -TLS_PRE_TCB_SIZE - TLS_TCB_OFFSET)
 
-/* Access to data in the thread descriptor is easy.  */
-# define THREAD_GETMEM(descr, member) \
-  descr->member
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-# define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 # define THREAD_GET_POINTER_GUARD()                            \
   (((tcbhead_t *) (READ_THREAD_POINTER ()                      \

diff --git a/sysdeps/nptl/tcb-access.h b/sysdeps/nptl/tcb-access.h
new file mode 100644 (file)
index 0000000..b4137b8
--- /dev/null
+++ b/sysdeps/nptl/tcb-access.h
@@ -0,0 +1,30 @@
+/* THREAD_* accessors.  Generic version based on struct pthread pointers.
+   Copyright (C) 2002-2021 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: These are for accessing the TCB of the *current* thread.
+   descr can be disregarded on some targets as an optimization.  See
+   i386 for an example.  */
+
+#define THREAD_GETMEM(descr, member) \
+  descr->member
+#define THREAD_GETMEM_NC(descr, member, idx) \
+  descr->member[idx]
+#define THREAD_SETMEM(descr, member, value) \
+  descr->member = (value)
+#define THREAD_SETMEM_NC(descr, member, idx, value) \
+  descr->member[idx] = (value)

diff --git a/sysdeps/powerpc/nptl/tls.h b/sysdeps/powerpc/nptl/tls.h
index cc93c44..7d2f16d 100644 (file)
--- a/sysdeps/powerpc/nptl/tls.h
+++ b/sysdeps/powerpc/nptl/tls.h
@@ -176,20 +176,7 @@ typedef struct
   REGISTER (64, 64, PT_THREAD_POINTER * 8,                                   \
            - TLS_TCB_OFFSET - TLS_PRE_TCB_SIZE)
 
-/* Read member of the thread descriptor directly.  */
-# define THREAD_GETMEM(descr, member) ((void)(descr), (THREAD_SELF)->member)
-
-/* Same as THREAD_GETMEM, but the member offset can be non-constant.  */
-# define THREAD_GETMEM_NC(descr, member, idx) \
-    ((void)(descr), (THREAD_SELF)->member[idx])
-
-/* Set member of the thread descriptor directly.  */
-# define THREAD_SETMEM(descr, member, value) \
-    ((void)(descr), (THREAD_SELF)->member = (value))
-
-/* Same as THREAD_SETMEM, but the member offset can be non-constant.  */
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-    ((void)(descr), (THREAD_SELF)->member[idx] = (value))
+# include <tcb-access.h>
 
 /* Set the stack guard field in TCB head.  */
 # define THREAD_SET_STACK_GUARD(value) \

diff --git a/sysdeps/riscv/nptl/tls.h b/sysdeps/riscv/nptl/tls.h
index e4bd736..a966d44 100644 (file)
--- a/sysdeps/riscv/nptl/tls.h
+++ b/sysdeps/riscv/nptl/tls.h
@@ -105,14 +105,7 @@ typedef struct
   REGISTER (64, 64, 4 * 8, - TLS_TCB_OFFSET - TLS_PRE_TCB_SIZE)
 
 /* Access to data in the thread descriptor is easy.  */
-# define THREAD_GETMEM(descr, member) \
-  descr->member
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-# define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* l_tls_offset == 0 is perfectly valid, so we have to use some different
    value to mean unset l_tls_offset.  */

diff --git a/sysdeps/s390/nptl/tls.h b/sysdeps/s390/nptl/tls.h
index 804486d..16c5811 100644 (file)
--- a/sysdeps/s390/nptl/tls.h
+++ b/sysdeps/s390/nptl/tls.h
@@ -135,15 +135,7 @@ typedef struct
 # define DB_THREAD_SELF REGISTER (32, 32, 18 * 4, 0) \
                        REGISTER (64, __WORDSIZE, 18 * 8, 0)
 
-/* Access to data in the thread descriptor is easy.  */
-#define THREAD_GETMEM(descr, member) \
-  descr->member
-#define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-#define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-#define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* Set the stack guard field in TCB head.  */
 #define THREAD_SET_STACK_GUARD(value) \

diff --git a/sysdeps/sh/nptl/tls.h b/sysdeps/sh/nptl/tls.h
index 2a9ee1d..aadd5be 100644 (file)
--- a/sysdeps/sh/nptl/tls.h
+++ b/sysdeps/sh/nptl/tls.h
@@ -113,19 +113,7 @@ typedef struct
 # define DB_THREAD_SELF \
   REGISTER (32, 32, REG_GBR * 4, -sizeof (struct pthread))
 
-/* Read member of the thread descriptor directly.  */
-# define THREAD_GETMEM(descr, member) (descr->member)
-
-/* Same as THREAD_GETMEM, but the member offset can be non-constant.  */
-# define THREAD_GETMEM_NC(descr, member, idx) (descr->member[idx])
-
-/* Set member of the thread descriptor directly.  */
-# define THREAD_SETMEM(descr, member, value) \
-    descr->member = (value)
-
-/* Same as THREAD_SETMEM, but the member offset can be non-constant.  */
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-    descr->member[idx] = (value)
+# include <tcb-access.h>
 
 #define THREAD_GET_POINTER_GUARD() \
   ({ tcbhead_t *__tcbp;                                                              \

diff --git a/sysdeps/sparc/nptl/tls.h b/sysdeps/sparc/nptl/tls.h
index 55955f3..d4e6e52 100644 (file)
--- a/sysdeps/sparc/nptl/tls.h
+++ b/sysdeps/sparc/nptl/tls.h
@@ -112,15 +112,7 @@ register struct pthread *__thread_self __asm__("%g7");
   REGISTER (32, 32, 10 * 4, 0) \
   REGISTER (64, __WORDSIZE, (6 * 8) + (__WORDSIZE==64?0:4), 0)
 
-/* Access to data in the thread descriptor is easy.  */
-#define THREAD_GETMEM(descr, member) \
-  descr->member
-#define THREAD_GETMEM_NC(descr, member, idx) \
-  descr->member[idx]
-#define THREAD_SETMEM(descr, member, value) \
-  descr->member = (value)
-#define THREAD_SETMEM_NC(descr, member, idx, value) \
-  descr->member[idx] = (value)
+# include <tcb-access.h>
 
 /* Set the stack guard field in TCB head.  */
 #define THREAD_SET_STACK_GUARD(value) \

diff --git a/sysdeps/x86_64/nptl/tcb-access.h b/sysdeps/x86_64/nptl/tcb-access.h
new file mode 100644 (file)
index 0000000..18848a7
--- /dev/null
+++ b/sysdeps/x86_64/nptl/tcb-access.h
@@ -0,0 +1,130 @@
+/* THREAD_* accessors.  x86_64 version.
+   Copyright (C) 2002-2021 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/>.  */
+
+/* Read member of the thread descriptor directly.  */
+# define THREAD_GETMEM(descr, member) \
+  ({ __typeof (descr->member) __value;                                       \
+     _Static_assert (sizeof (__value) == 1                                   \
+                    || sizeof (__value) == 4                                 \
+                    || sizeof (__value) == 8,                                \
+                    "size of per-thread data");                              \
+     if (sizeof (__value) == 1)                                                      \
+       asm volatile ("movb %%fs:%P2,%b0"                                     \
+                    : "=q" (__value)                                         \
+                    : "0" (0), "i" (offsetof (struct pthread, member)));     \
+     else if (sizeof (__value) == 4)                                         \
+       asm volatile ("movl %%fs:%P1,%0"                                              \
+                    : "=r" (__value)                                         \
+                    : "i" (offsetof (struct pthread, member)));              \
+     else /* 8 */                                                                    \
+       {                                                                     \
+        asm volatile ("movq %%fs:%P1,%q0"                                    \
+                      : "=r" (__value)                                       \
+                      : "i" (offsetof (struct pthread, member)));            \
+       }                                                                     \
+     __value; })
+
+
+/* Same as THREAD_GETMEM, but the member offset can be non-constant.  */
+# define THREAD_GETMEM_NC(descr, member, idx) \
+  ({ __typeof (descr->member[0]) __value;                                    \
+     _Static_assert (sizeof (__value) == 1                                   \
+                    || sizeof (__value) == 4                                 \
+                    || sizeof (__value) == 8,                                \
+                    "size of per-thread data");                              \
+     if (sizeof (__value) == 1)                                                      \
+       asm volatile ("movb %%fs:%P2(%q3),%b0"                                \
+                    : "=q" (__value)                                         \
+                    : "0" (0), "i" (offsetof (struct pthread, member[0])),   \
+                      "r" (idx));                                            \
+     else if (sizeof (__value) == 4)                                         \
+       asm volatile ("movl %%fs:%P1(,%q2,4),%0"                                      \
+                    : "=r" (__value)                                         \
+                    : "i" (offsetof (struct pthread, member[0])), "r" (idx));\
+     else /* 8 */                                                            \
+       {                                                                     \
+        asm volatile ("movq %%fs:%P1(,%q2,8),%q0"                            \
+                      : "=r" (__value)                                       \
+                      : "i" (offsetof (struct pthread, member[0])),          \
+                        "r" (idx));                                          \
+       }                                                                     \
+     __value; })
+
+
+/* Loading addresses of objects on x86-64 needs to be treated special
+   when generating PIC code.  */
+#ifdef __pic__
+# define IMM_MODE "nr"
+#else
+# define IMM_MODE "ir"
+#endif
+
+
+/* Set member of the thread descriptor directly.  */
+# define THREAD_SETMEM(descr, member, value) \
+  ({                                                                         \
+     _Static_assert (sizeof (descr->member) == 1                             \
+                    || sizeof (descr->member) == 4                           \
+                    || sizeof (descr->member) == 8,                          \
+                    "size of per-thread data");                              \
+     if (sizeof (descr->member) == 1)                                        \
+       asm volatile ("movb %b0,%%fs:%P1" :                                   \
+                    : "iq" (value),                                          \
+                      "i" (offsetof (struct pthread, member)));              \
+     else if (sizeof (descr->member) == 4)                                   \
+       asm volatile ("movl %0,%%fs:%P1" :                                    \
+                    : IMM_MODE (value),                                      \
+                      "i" (offsetof (struct pthread, member)));              \
+     else /* 8 */                                                            \
+       {                                                                     \
+        /* Since movq takes a signed 32-bit immediate or a register source   \
+           operand, use "er" constraint for 32-bit signed integer constant   \
+           or register.  */                                                  \
+        asm volatile ("movq %q0,%%fs:%P1" :                                  \
+                      : "er" ((uint64_t) cast_to_integer (value)),           \
+                        "i" (offsetof (struct pthread, member)));            \
+       }})
+
+
+/* Same as THREAD_SETMEM, but the member offset can be non-constant.  */
+# define THREAD_SETMEM_NC(descr, member, idx, value) \
+  ({                                                                         \
+     _Static_assert (sizeof (descr->member[0]) == 1                          \
+                    || sizeof (descr->member[0]) == 4                        \
+                    || sizeof (descr->member[0]) == 8,                       \
+                    "size of per-thread data");                              \
+     if (sizeof (descr->member[0]) == 1)                                     \
+       asm volatile ("movb %b0,%%fs:%P1(%q2)" :                                      \
+                    : "iq" (value),                                          \
+                      "i" (offsetof (struct pthread, member[0])),            \
+                      "r" (idx));                                            \
+     else if (sizeof (descr->member[0]) == 4)                                \
+       asm volatile ("movl %0,%%fs:%P1(,%q2,4)" :                            \
+                    : IMM_MODE (value),                                      \
+                      "i" (offsetof (struct pthread, member[0])),            \
+                      "r" (idx));                                            \
+     else /* 8 */                                                            \
+       {                                                                     \
+        /* Since movq takes a signed 32-bit immediate or a register source   \
+           operand, use "er" constraint for 32-bit signed integer constant   \
+           or register.  */                                                  \
+        asm volatile ("movq %q0,%%fs:%P1(,%q2,8)" :                          \
+                      : "er" ((uint64_t) cast_to_integer (value)),           \
+                        "i" (offsetof (struct pthread, member[0])),          \
+                        "r" (idx));                                          \
+       }})

diff --git a/sysdeps/x86_64/nptl/tls.h b/sysdeps/x86_64/nptl/tls.h
index b0d0443..a395798 100644 (file)
--- a/sysdeps/x86_64/nptl/tls.h
+++ b/sysdeps/x86_64/nptl/tls.h
@@ -195,119 +195,7 @@ _Static_assert (offsetof (tcbhead_t, __glibc_unused2) == 0x80,
 # define DB_THREAD_SELF_INCLUDE  <sys/reg.h> /* For the FS constant.  */
 # define DB_THREAD_SELF CONST_THREAD_AREA (64, FS)
 
-/* Read member of the thread descriptor directly.  */
-# define THREAD_GETMEM(descr, member) \
-  ({ __typeof (descr->member) __value;                                       \
-     _Static_assert (sizeof (__value) == 1                                   \
-                    || sizeof (__value) == 4                                 \
-                    || sizeof (__value) == 8,                                \
-                    "size of per-thread data");                              \
-     if (sizeof (__value) == 1)                                                      \
-       asm volatile ("movb %%fs:%P2,%b0"                                     \
-                    : "=q" (__value)                                         \
-                    : "0" (0), "i" (offsetof (struct pthread, member)));     \
-     else if (sizeof (__value) == 4)                                         \
-       asm volatile ("movl %%fs:%P1,%0"                                              \
-                    : "=r" (__value)                                         \
-                    : "i" (offsetof (struct pthread, member)));              \
-     else /* 8 */                                                                    \
-       {                                                                     \
-        asm volatile ("movq %%fs:%P1,%q0"                                    \
-                      : "=r" (__value)                                       \
-                      : "i" (offsetof (struct pthread, member)));            \
-       }                                                                     \
-     __value; })
-
-
-/* Same as THREAD_GETMEM, but the member offset can be non-constant.  */
-# define THREAD_GETMEM_NC(descr, member, idx) \
-  ({ __typeof (descr->member[0]) __value;                                    \
-     _Static_assert (sizeof (__value) == 1                                   \
-                    || sizeof (__value) == 4                                 \
-                    || sizeof (__value) == 8,                                \
-                    "size of per-thread data");                              \
-     if (sizeof (__value) == 1)                                                      \
-       asm volatile ("movb %%fs:%P2(%q3),%b0"                                \
-                    : "=q" (__value)                                         \
-                    : "0" (0), "i" (offsetof (struct pthread, member[0])),   \
-                      "r" (idx));                                            \
-     else if (sizeof (__value) == 4)                                         \
-       asm volatile ("movl %%fs:%P1(,%q2,4),%0"                                      \
-                    : "=r" (__value)                                         \
-                    : "i" (offsetof (struct pthread, member[0])), "r" (idx));\
-     else /* 8 */                                                            \
-       {                                                                     \
-        asm volatile ("movq %%fs:%P1(,%q2,8),%q0"                            \
-                      : "=r" (__value)                                       \
-                      : "i" (offsetof (struct pthread, member[0])),          \
-                        "r" (idx));                                          \
-       }                                                                     \
-     __value; })
-
-
-/* Loading addresses of objects on x86-64 needs to be treated special
-   when generating PIC code.  */
-#ifdef __pic__
-# define IMM_MODE "nr"
-#else
-# define IMM_MODE "ir"
-#endif
-
-
-/* Set member of the thread descriptor directly.  */
-# define THREAD_SETMEM(descr, member, value) \
-  ({                                                                         \
-     _Static_assert (sizeof (descr->member) == 1                             \
-                    || sizeof (descr->member) == 4                           \
-                    || sizeof (descr->member) == 8,                          \
-                    "size of per-thread data");                              \
-     if (sizeof (descr->member) == 1)                                        \
-       asm volatile ("movb %b0,%%fs:%P1" :                                   \
-                    : "iq" (value),                                          \
-                      "i" (offsetof (struct pthread, member)));              \
-     else if (sizeof (descr->member) == 4)                                   \
-       asm volatile ("movl %0,%%fs:%P1" :                                    \
-                    : IMM_MODE (value),                                      \
-                      "i" (offsetof (struct pthread, member)));              \
-     else /* 8 */                                                            \
-       {                                                                     \
-        /* Since movq takes a signed 32-bit immediate or a register source   \
-           operand, use "er" constraint for 32-bit signed integer constant   \
-           or register.  */                                                  \
-        asm volatile ("movq %q0,%%fs:%P1" :                                  \
-                      : "er" ((uint64_t) cast_to_integer (value)),           \
-                        "i" (offsetof (struct pthread, member)));            \
-       }})
-
-
-/* Same as THREAD_SETMEM, but the member offset can be non-constant.  */
-# define THREAD_SETMEM_NC(descr, member, idx, value) \
-  ({                                                                         \
-     _Static_assert (sizeof (descr->member[0]) == 1                          \
-                    || sizeof (descr->member[0]) == 4                        \
-                    || sizeof (descr->member[0]) == 8,                       \
-                    "size of per-thread data");                              \
-     if (sizeof (descr->member[0]) == 1)                                     \
-       asm volatile ("movb %b0,%%fs:%P1(%q2)" :                                      \
-                    : "iq" (value),                                          \
-                      "i" (offsetof (struct pthread, member[0])),            \
-                      "r" (idx));                                            \
-     else if (sizeof (descr->member[0]) == 4)                                \
-       asm volatile ("movl %0,%%fs:%P1(,%q2,4)" :                            \
-                    : IMM_MODE (value),                                      \
-                      "i" (offsetof (struct pthread, member[0])),            \
-                      "r" (idx));                                            \
-     else /* 8 */                                                            \
-       {                                                                     \
-        /* Since movq takes a signed 32-bit immediate or a register source   \
-           operand, use "er" constraint for 32-bit signed integer constant   \
-           or register.  */                                                  \
-        asm volatile ("movq %q0,%%fs:%P1(,%q2,8)" :                          \
-                      : "er" ((uint64_t) cast_to_integer (value)),           \
-                        "i" (offsetof (struct pthread, member[0])),          \
-                        "r" (idx));                                          \
-       }})
-
+# include <tcb-access.h>
 
 /* Set the stack guard field in TCB head.  */
 # define THREAD_SET_STACK_GUARD(value) \