Re: [PATCH] riscv: Implement TLS Descriptors

"Andreas K. Huettel" <[email protected]> Wed, 15 Jul 2026 10:57:35 +0900
Newsgroups	gmane.comp.lib.glibc.alpha
Organization	Gentoo Linux
Message-ID	<[email protected]>
Am Dienstag, 14. Juli 2026, 23:30:42 Japanische Normalzeit schrieb Luke Zhuang:
> From: "Luke Zhuang" <[email protected]>
> 
> Implement TLS Descriptors (TLSDESC) for RISC-V, as specified by the
> RISC-V psABI TLSDESC extension [1].
> 

That's post-release material.

> This adds the RISC-V TLSDESC relocation handling and the three resolver
> entry points used by the dynamic loader:
> 
>   _dl_tlsdesc_undefweak
>   _dl_tlsdesc_return
>   _dl_tlsdesc_dynamic
> 
> The dynamic resolver implements the usual fast path by checking the DTV
> generation counter, and falls back to __tls_get_addr on the slow path.
> 
> This work is based on Tatsuyuki Ishi's original patch series [2], and
> is being relanded with his authorization.  The reland includes the
> following updates:
> 
>   * Do not save and restore vector registers in _dl_tlsdesc_dynamic.
>     The RISC-V psABI now defines vector registers and vector CSRs as
>     caller-clobbered across TLSDESC calls [3], so preserving live vector
>     state is the compiler's responsibility.
> 
>   * Call HIDDEN_JUMPTARGET(__tls_get_addr) from ld.so, avoiding a PLT
>     reference to __tls_get_addr.
> 
>   * Publish TLSDESC entries in elf_machine_rela in arg-before-entry
>     order, and use a volatile tlsdesc pointer, matching the ordering
>     used by other architectures.
> 
>   * Add sysdeps/riscv/tst-gnu2-tls2.h to test that the RISC-V TLSDESC
>     resolver preserves the required caller-saved GPR and FPR state
>     across the slow path.
> 
> Basic GCC and binutils support for RISC-V TLSDESC relocations is already
> upstream [4][5]. Linker relaxation support is on the way but should not
> be a blocker.
> 
> [1] https://github.com/riscv-non-isa/riscv-elf-psabi-doc/pull/373
> [2] https://inbox.sourceware.org/libc-alpha/[email protected]/T/#u
> [3] https://github.com/riscv-non-isa/riscv-elf-psabi-doc/pull/496
> [4] https://gcc.gnu.org/cgit/gcc/commit/?id=97069657c4e40b209c7b774e12faaca13812a86c
> [5] https://sourceware.org/git/?p=binutils-gdb.git;a=commitdiff;h=159afbb7617d2c8a9cd3f3350374711f37f60442
> 
> Co-authored-by: Tatsuyuki Ishi <[email protected]>
> Signed-off-by: Luke Zhuang <[email protected]>
> ---
>  sysdeps/riscv/Makefile        |  10 ++
>  sysdeps/riscv/dl-lookupcfg.h  |  27 +++++
>  sysdeps/riscv/dl-machine.h    |  54 ++++++++-
>  sysdeps/riscv/dl-tlsdesc.S    | 221 ++++++++++++++++++++++++++++++++++
>  sysdeps/riscv/dl-tlsdesc.h    |  48 ++++++++
>  sysdeps/riscv/linkmap.h       |   1 +
>  sysdeps/riscv/preconfigure    |   1 +
>  sysdeps/riscv/tlsdesc.c       |  38 ++++++
>  sysdeps/riscv/tlsdesc.sym     |  19 +++
>  sysdeps/riscv/tst-gnu2-tls2.h | 201 +++++++++++++++++++++++++++++++
>  10 files changed, 619 insertions(+), 1 deletion(-)
>  create mode 100644 sysdeps/riscv/dl-lookupcfg.h
>  create mode 100644 sysdeps/riscv/dl-tlsdesc.S
>  create mode 100644 sysdeps/riscv/dl-tlsdesc.h
>  create mode 100644 sysdeps/riscv/tlsdesc.c
>  create mode 100644 sysdeps/riscv/tlsdesc.sym
>  create mode 100644 sysdeps/riscv/tst-gnu2-tls2.h
> 
> diff --git a/sysdeps/riscv/Makefile b/sysdeps/riscv/Makefile
> index c08753ae8a..fc16081cde 100644
> --- a/sysdeps/riscv/Makefile
> +++ b/sysdeps/riscv/Makefile
> @@ -4,6 +4,16 @@ endif
>  
>  ifeq ($(subdir),elf)
>  gen-as-const-headers += dl-link.sym
> +sysdep-dl-routines += \
> +  dl-tlsdesc \
> +  tlsdesc \
> +  # routines
> +endif
> +
> +ifeq ($(subdir),csu)
> +gen-as-const-headers += \
> +  tlsdesc.sym \
> +  # gen-as-const-headers
>  endif
>  
>  # RISC-V's assembler also needs to know about PIC as it changes the definition
> diff --git a/sysdeps/riscv/dl-lookupcfg.h b/sysdeps/riscv/dl-lookupcfg.h
> new file mode 100644
> index 0000000000..414c8c8f8e
> --- /dev/null
> +++ b/sysdeps/riscv/dl-lookupcfg.h
> @@ -0,0 +1,27 @@
> +/* Configuration of lookup functions.
> +   Copyright (C) 2026 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/>.  */
> +
> +#define DL_UNMAP_IS_SPECIAL
> +
> +#include_next <dl-lookupcfg.h>
> +
> +struct link_map;
> +
> +extern void _dl_unmap (struct link_map *map);
> +
> +#define DL_UNMAP(map) _dl_unmap (map)
> diff --git a/sysdeps/riscv/dl-machine.h b/sysdeps/riscv/dl-machine.h
> index babb52af20..79f0d02cab 100644
> --- a/sysdeps/riscv/dl-machine.h
> +++ b/sysdeps/riscv/dl-machine.h
> @@ -25,6 +25,7 @@
>  #include <elf/elf.h>
>  #include <sys/asm.h>
>  #include <dl-tls.h>
> +#include <dl-tlsdesc.h>
>  #include <dl-irel.h>
>  #include <dl-static-tls.h>
>  #include <dl-machine-rel.h>
> @@ -51,7 +52,8 @@
>       || (__WORDSIZE == 32 && (type) == R_RISCV_TLS_TPREL32)	\
>       || (__WORDSIZE == 64 && (type) == R_RISCV_TLS_DTPREL64)	\
>       || (__WORDSIZE == 64 && (type) == R_RISCV_TLS_DTPMOD64)	\
> -     || (__WORDSIZE == 64 && (type) == R_RISCV_TLS_TPREL64)))	\
> +     || (__WORDSIZE == 64 && (type) == R_RISCV_TLS_TPREL64)	\
> +     || ((type) == R_RISCV_TLSDESC)))				\
>     | (ELF_RTYPE_CLASS_COPY * ((type) == R_RISCV_COPY)))
>  
>  /* Return nonzero iff ELF header is compatible with the running host.  */
> @@ -220,6 +222,37 @@ elf_machine_rela (struct link_map *map, struct r_scope_elem *scope[],
>  	}
>        break;
>  
> +    case R_RISCV_TLSDESC:
> +      {
> +	struct tlsdesc volatile *td =
> +	    (struct tlsdesc volatile *)reloc_addr;
> +	if (!sym)
> +	  {
> +	    td->arg = (void *) reloc->r_addend;
> +	    td->entry = _dl_tlsdesc_undefweak;
> +	  }
> +	else
> +	  {
> +# ifndef SHARED
> +	    CHECK_STATIC_TLS (map, sym_map);
> +# else
> +	    if (!TRY_STATIC_TLS (map, sym_map))
> +	      {
> +		td->arg = _dl_make_tlsdesc_dynamic
> +		  (sym_map, sym->st_value + reloc->r_addend);
> +		td->entry = _dl_tlsdesc_dynamic;
> +	      }
> +	    else
> +# endif
> +	      {
> +		td->arg
> +		  = (void *) (TLS_TPREL_VALUE (sym_map, sym) + reloc->r_addend);
> +		td->entry = _dl_tlsdesc_return;
> +	      }
> +	  }
> +	break;
> +      }
> +
>      case R_RISCV_COPY:
>        {
>  	if (__glibc_unlikely (sym == NULL))
> @@ -290,6 +323,25 @@ elf_machine_lazy_rel (struct link_map *map, struct r_scope_elem *scope[],
>        else
>  	*reloc_addr = map->l_mach.plt;
>      }
> +  else if (__glibc_likely (r_type == R_RISCV_TLSDESC))
> +    {
> +      const Elf_Symndx symndx = ELFW (R_SYM) (reloc->r_info);
> +      const ElfW (Sym) *symtab = (const void *)D_PTR (map, l_info[DT_SYMTAB]);
> +      const ElfW (Sym) *sym = &symtab[symndx];
> +      const struct r_found_version *version = NULL;
> +
> +      if (map->l_info[VERSYMIDX (DT_VERSYM)] != NULL)
> +	{
> +	  const ElfW (Half) *vernum =
> +	      (const void *)D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
> +	  version = &map->l_versions[vernum[symndx] & 0x7fff];
> +	}
> +
> +      /* Always initialize TLS descriptors completely, because lazy
> +	 initialization requires synchronization at every TLS access.  */
> +      elf_machine_rela (map, scope, reloc, sym, version, reloc_addr,
> +			skip_ifunc);
> +    }
>    else if (__glibc_unlikely (r_type == R_RISCV_IRELATIVE))
>      {
>        ElfW(Addr) value = map->l_addr + reloc->r_addend;
> diff --git a/sysdeps/riscv/dl-tlsdesc.S b/sysdeps/riscv/dl-tlsdesc.S
> new file mode 100644
> index 0000000000..b11bd25e62
> --- /dev/null
> +++ b/sysdeps/riscv/dl-tlsdesc.S
> @@ -0,0 +1,221 @@
> +/* Thread-local storage handling in the ELF dynamic linker.
> +   RISC-V version.
> +   Copyright (C) 2026 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>
> +#include <tls.h>
> +#include <tlsdesc.h>
> +
> +/* The fast path does not call function and does not need to align sp, but
> +   to simplify handling when going into the slow path, keep sp aligned all
> +   the time.
> + */
> +#define FRAME_SIZE_FAST (-((-3 * SZREG) & ALMASK))
> +
> +/* The slow path save slot layout, from lower address to higher address, is:
> +   1. 12 GP registers
> +   2. 20 FP registers
> +
> +   Besides a0 and t0, the vector registers are also caller-saved per the psABI
> +   (riscv-non-isa/riscv-elf-psabi-doc#496) so they are not preserved across
> +   the TLSDESC ifunc.
> + */
> +#if defined(__riscv_float_abi_soft)
> +# define FRAME_SIZE_SLOW (-((-12 * SZREG) & ALMASK))
> +#else
> +# define FRAME_SIZE_SLOW (-((-12 * SZREG - 20 * SZFREG) & ALMASK))
> +#endif
> +
> +	.text
> +
> +	/* Compute the thread pointer offset for symbols in the static
> +	   TLS block.  The offset is the same for all threads.
> +	   Prototype:
> +	   _dl_tlsdesc_return (tlsdesc *) ;
> +	 */
> +ENTRY (_dl_tlsdesc_return)
> +	REG_L a0, TLSDESC_ARG(a0)
> +	jr t0
> +END (_dl_tlsdesc_return)
> +
> +	/* Handler for undefined weak TLS symbols.
> +	   Prototype:
> +	   _dl_tlsdesc_undefweak (tlsdesc *);
> +
> +	   The second word of the descriptor contains the addend.
> +	   Return the addend minus the thread pointer.  This ensures
> +	   that when the caller adds on the thread pointer it gets back
> +	   the addend.  */
> +
> +ENTRY (_dl_tlsdesc_undefweak)
> +	REG_L a0, TLSDESC_ARG(a0)
> +	sub a0, a0, tp
> +	jr t0
> +END (_dl_tlsdesc_undefweak)
> +
> +#ifdef SHARED
> +	/* Handler for dynamic TLS symbols.
> +	   Prototype:
> +	   _dl_tlsdesc_dynamic (tlsdesc *) ;
> +
> +	   The second word of the descriptor points to a
> +	   tlsdesc_dynamic_arg structure.
> +
> +	   Returns the offset between the thread pointer and the
> +	   object referenced by the argument.
> +
> +	   unsigned long
> +	   _dl_tlsdesc_dynamic (struct tlsdesc *tdp)
> +	   {
> +	     struct tlsdesc_dynamic_arg *td = tdp->arg;
> +	     dtv_t *dtv = *(dtv_t **)((char *)__thread_pointer + TCBHEAD_DTV);
> +	     if (__builtin_expect (td->gen_count <= dtv[0].counter
> +		&& (dtv[td->tlsinfo.ti_module].pointer.val
> +		    != TLS_DTV_UNALLOCATED),
> +		1))
> +	       return dtv[td->tlsinfo.ti_module].pointer.val
> +		+ td->tlsinfo.ti_offset
> +		- __thread_pointer;
> +
> +	     return __tls_get_addr (&td->tlsinfo) - __thread_pointer;
> +	   }
> +	 */
> +
> +ENTRY (_dl_tlsdesc_dynamic)
> +	/* Save just enough registers to support fast path, if we fall
> +	   into slow path we will save additional registers.  */
> +	add	sp, sp, -FRAME_SIZE_FAST
> +	REG_S	t0, 0*SZREG(sp)
> +	REG_S	t1, 1*SZREG(sp)
> +	REG_S	t2, 2*SZREG(sp)
> +
> +	/* t0 = dtv */
> +	REG_L	t0, TCBHEAD_DTV(tp)
> +	/* a0 = tdp->arg */
> +	REG_L	a0, TLSDESC_ARG(a0)
> +	/* t1 = td->gen_count */
> +	REG_L	t1, TLSDESC_GEN_COUNT(a0)
> +	/* t2 = dtv[0].counter */
> +	REG_L	t2, DTV_COUNTER(t0)
> +	bltu	t2, t1, .Lslow
> +	/* t1 = td->tlsinfo.ti_module */
> +	REG_L	t1, TLSDESC_MODID(a0)
> +	slli	t1, t1, PTRLOG + 1 /* sizeof(dtv_t) == sizeof(void*) * 2 */
> +	add	t1, t1, t0
> +	/* t1 = dtv[td->tlsinfo.ti_module].pointer.val  */
> +	REG_L	t1, 0(t1)
> +	li	t2, TLS_DTV_UNALLOCATED
> +	beq	t1, t2, .Lslow
> +	/* t2 = td->tlsinfo.ti_offset */
> +	REG_L	t2, TLSDESC_MODOFF(a0)
> +	add	a0, t1, t2
> +.Lret:
> +	sub	a0, a0, tp
> +	REG_L	t0, 0*SZREG(sp)
> +	REG_L	t1, 1*SZREG(sp)
> +	REG_L	t2, 2*SZREG(sp)
> +	add	sp, sp, FRAME_SIZE_FAST
> +	jr	t0
> +.Lslow:
> +	/* This is the slow path.  We need to call __tls_get_addr() which
> +	   means we need to save and restore all the register that the
> +	   callee will trash.  */
> +
> +	/* Save the remaining registers that we must treat as caller save.  */
> +	addi	sp, sp, -FRAME_SIZE_SLOW
> +	REG_S	ra, 0*SZREG(sp)
> +	REG_S	a1, 1*SZREG(sp)
> +	REG_S	a2, 2*SZREG(sp)
> +	REG_S	a3, 3*SZREG(sp)
> +	REG_S	a4, 4*SZREG(sp)
> +	REG_S	a5, 5*SZREG(sp)
> +	REG_S	a6, 6*SZREG(sp)
> +	REG_S	a7, 7*SZREG(sp)
> +	REG_S	t3, 8*SZREG(sp)
> +	REG_S	t4, 9*SZREG(sp)
> +	REG_S	t5, 10*SZREG(sp)
> +	REG_S	t6, 11*SZREG(sp)
> +
> +#ifndef __riscv_float_abi_soft
> +	FREG_S	ft0, (12*SZREG + 0*SZFREG)(sp)
> +	FREG_S	ft1, (12*SZREG + 1*SZFREG)(sp)
> +	FREG_S	ft2, (12*SZREG + 2*SZFREG)(sp)
> +	FREG_S	ft3, (12*SZREG + 3*SZFREG)(sp)
> +	FREG_S	ft4, (12*SZREG + 4*SZFREG)(sp)
> +	FREG_S	ft5, (12*SZREG + 5*SZFREG)(sp)
> +	FREG_S	ft6, (12*SZREG + 6*SZFREG)(sp)
> +	FREG_S	ft7, (12*SZREG + 7*SZFREG)(sp)
> +	FREG_S	fa0, (12*SZREG + 8*SZFREG)(sp)
> +	FREG_S	fa1, (12*SZREG + 9*SZFREG)(sp)
> +	FREG_S	fa2, (12*SZREG + 10*SZFREG)(sp)
> +	FREG_S	fa3, (12*SZREG + 11*SZFREG)(sp)
> +	FREG_S	fa4, (12*SZREG + 12*SZFREG)(sp)
> +	FREG_S	fa5, (12*SZREG + 13*SZFREG)(sp)
> +	FREG_S	fa6, (12*SZREG + 14*SZFREG)(sp)
> +	FREG_S	fa7, (12*SZREG + 15*SZFREG)(sp)
> +	FREG_S	ft8, (12*SZREG + 16*SZFREG)(sp)
> +	FREG_S	ft9, (12*SZREG + 17*SZFREG)(sp)
> +	FREG_S	ft10, (12*SZREG + 18*SZFREG)(sp)
> +	FREG_S	ft11, (12*SZREG + 19*SZFREG)(sp)
> +#endif
> +
> +	call	HIDDEN_JUMPTARGET(__tls_get_addr)
> +	addi	a0, a0, -TLS_DTV_OFFSET
> +
> +	REG_L	ra, 0*SZREG(sp)
> +	REG_L	a1, 1*SZREG(sp)
> +	REG_L	a2, 2*SZREG(sp)
> +	REG_L	a3, 3*SZREG(sp)
> +	REG_L	a4, 4*SZREG(sp)
> +	REG_L	a5, 5*SZREG(sp)
> +	REG_L	a6, 6*SZREG(sp)
> +	REG_L	a7, 7*SZREG(sp)
> +	REG_L	t3, 8*SZREG(sp)
> +	REG_L	t4, 9*SZREG(sp)
> +	REG_L	t5, 10*SZREG(sp)
> +	REG_L	t6, 11*SZREG(sp)
> +
> +#ifndef __riscv_float_abi_soft
> +	FREG_L	ft0, (12*SZREG + 0*SZFREG)(sp)
> +	FREG_L	ft1, (12*SZREG + 1*SZFREG)(sp)
> +	FREG_L	ft2, (12*SZREG + 2*SZFREG)(sp)
> +	FREG_L	ft3, (12*SZREG + 3*SZFREG)(sp)
> +	FREG_L	ft4, (12*SZREG + 4*SZFREG)(sp)
> +	FREG_L	ft5, (12*SZREG + 5*SZFREG)(sp)
> +	FREG_L	ft6, (12*SZREG + 6*SZFREG)(sp)
> +	FREG_L	ft7, (12*SZREG + 7*SZFREG)(sp)
> +	FREG_L	fa0, (12*SZREG + 8*SZFREG)(sp)
> +	FREG_L	fa1, (12*SZREG + 9*SZFREG)(sp)
> +	FREG_L	fa2, (12*SZREG + 10*SZFREG)(sp)
> +	FREG_L	fa3, (12*SZREG + 11*SZFREG)(sp)
> +	FREG_L	fa4, (12*SZREG + 12*SZFREG)(sp)
> +	FREG_L	fa5, (12*SZREG + 13*SZFREG)(sp)
> +	FREG_L	fa6, (12*SZREG + 14*SZFREG)(sp)
> +	FREG_L	fa7, (12*SZREG + 15*SZFREG)(sp)
> +	FREG_L	ft8, (12*SZREG + 16*SZFREG)(sp)
> +	FREG_L	ft9, (12*SZREG + 17*SZFREG)(sp)
> +	FREG_L	ft10, (12*SZREG + 18*SZFREG)(sp)
> +	FREG_L	ft11, (12*SZREG + 19*SZFREG)(sp)
> +#endif
> +
> +	addi	sp, sp, FRAME_SIZE_SLOW
> +	j	.Lret
> +END (_dl_tlsdesc_dynamic)
> +	.hidden HIDDEN_JUMPTARGET(__tls_get_addr)
> +#endif
> diff --git a/sysdeps/riscv/dl-tlsdesc.h b/sysdeps/riscv/dl-tlsdesc.h
> new file mode 100644
> index 0000000000..366b454183
> --- /dev/null
> +++ b/sysdeps/riscv/dl-tlsdesc.h
> @@ -0,0 +1,48 @@
> +/* Thread-local storage descriptor handling in the ELF dynamic linker.
> +   RISC-V version.
> +   Copyright (C) 2026 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_TLSDESC_H
> +# define _DL_TLSDESC_H 1
> +
> +#include <dl-tls.h>
> +
> +/* Type used to represent a TLS descriptor in the GOT.  */
> +struct tlsdesc
> +{
> +  unsigned long (*entry) (struct tlsdesc *);
> +  void *arg;
> +};
> +
> +/* Type used as the argument in a TLS descriptor for a symbol that
> +   needs dynamic TLS offsets.  */
> +struct tlsdesc_dynamic_arg
> +{
> +  tls_index tlsinfo;
> +  size_t gen_count;
> +};
> +
> +extern unsigned long _dl_tlsdesc_return (struct tlsdesc *) attribute_hidden;
> +extern unsigned long _dl_tlsdesc_undefweak (struct tlsdesc *) attribute_hidden;
> +
> +# ifdef SHARED
> +extern void *_dl_make_tlsdesc_dynamic (struct link_map *, size_t);
> +extern unsigned long _dl_tlsdesc_dynamic (struct tlsdesc *) attribute_hidden;
> +# endif
> +
> +#endif /* _DL_TLSDESC_H */
> diff --git a/sysdeps/riscv/linkmap.h b/sysdeps/riscv/linkmap.h
> index ac170bb342..2fa3f6d43f 100644
> --- a/sysdeps/riscv/linkmap.h
> +++ b/sysdeps/riscv/linkmap.h
> @@ -1,4 +1,5 @@
>  struct link_map_machine
>    {
>      ElfW(Addr) plt; /* Address of .plt.  */
> +    void *tlsdesc_table; /* Address of TLS descriptor hash table.  */
>    };
> diff --git a/sysdeps/riscv/preconfigure b/sysdeps/riscv/preconfigure
> index 57fe6822cf..7c30cf045c 100755
> --- a/sysdeps/riscv/preconfigure
> +++ b/sysdeps/riscv/preconfigure
> @@ -74,6 +74,7 @@ riscv*)
>  
>      base_machine=riscv
>      machine=riscv/rv$xlen/$float_machine
> +    mtls_descriptor=desc
>  
>      printf "%s\n" "#define RISCV_ABI_XLEN $xlen" >>confdefs.h
>  
> diff --git a/sysdeps/riscv/tlsdesc.c b/sysdeps/riscv/tlsdesc.c
> new file mode 100644
> index 0000000000..f2cef3db77
> --- /dev/null
> +++ b/sysdeps/riscv/tlsdesc.c
> @@ -0,0 +1,38 @@
> +/* Manage TLS descriptors.  RISC-V version.
> +   Copyright (C) 2026 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 <ldsodefs.h>
> +#include <tls.h>
> +#include <dl-tls.h>
> +#include <dl-tlsdesc.h>
> +#include <dl-unmap-segments.h>
> +#include <tlsdeschtab.h>
> +
> +/* Unmap the dynamic object, but also release its TLS descriptor table
> +   if there is one.  */
> +
> +void
> +_dl_unmap (struct link_map *map)
> +{
> +  _dl_unmap_segments (map);
> +
> +#ifdef SHARED
> +  if (map->l_mach.tlsdesc_table)
> +    htab_delete (map->l_mach.tlsdesc_table);
> +#endif
> +}
> diff --git a/sysdeps/riscv/tlsdesc.sym b/sysdeps/riscv/tlsdesc.sym
> new file mode 100644
> index 0000000000..652e72ea58
> --- /dev/null
> +++ b/sysdeps/riscv/tlsdesc.sym
> @@ -0,0 +1,19 @@
> +#include <stddef.h>
> +#include <sysdep.h>
> +#include <tls.h>
> +#include <link.h>
> +#include <dl-tls.h>
> +#include <dl-tlsdesc.h>
> +
> +--
> +
> +-- Abuse tls.h macros to derive offsets relative to the thread register.
> +
> +TLSDESC_ARG		offsetof(struct tlsdesc, arg)
> +TLSDESC_GEN_COUNT	offsetof(struct tlsdesc_dynamic_arg, gen_count)
> +TLSDESC_MODID		offsetof(struct tlsdesc_dynamic_arg, tlsinfo.ti_module)
> +TLSDESC_MODOFF		offsetof(struct tlsdesc_dynamic_arg, tlsinfo.ti_offset)
> +TCBHEAD_DTV		offsetof(tcbhead_t, dtv) - sizeof(tcbhead_t) - TLS_TCB_OFFSET
> +DTV_COUNTER		offsetof(dtv_t, counter)
> +TLS_DTV_UNALLOCATED	TLS_DTV_UNALLOCATED
> +TLS_DTV_OFFSET		TLS_DTV_OFFSET
> diff --git a/sysdeps/riscv/tst-gnu2-tls2.h b/sysdeps/riscv/tst-gnu2-tls2.h
> new file mode 100644
> index 0000000000..ef5b345ef2
> --- /dev/null
> +++ b/sysdeps/riscv/tst-gnu2-tls2.h
> @@ -0,0 +1,201 @@
> +/* Test TLSDESC relocation.  RISC-V version.
> +   Copyright (C) 2026 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 <stdio.h>
> +#include <string.h>
> +#include <stdlib.h>
> +
> +/* The TLSDESC calling convention requires _dl_tlsdesc_dynamic to preserve
> +   every register except a0 (the argument/return value) and t0 (the return
> +   address).  On the slow path it calls __tls_get_addr, an ordinary function
> +   that may clobber all caller-saved registers, so the resolver must save and
> +   restore the caller-saved general-purpose registers a1-a7 and t1-t6, and
> +   the 20 caller-saved floating-point registers (ft0-ft7, fa0-fa7, ft8-ft11),
> +   around that call.  Load sentinel values into them before the TLS access and
> +   verify that they are unchanged afterwards.
> +
> +   Vector registers and vector CSRs are intentionally *not* checked: per the
> +   RISC-V psABI they are clobbered by the TLSDESC call (see
> +   riscv-non-isa/riscv-elf-psabi-doc#496), so the compiler, not the dynamic
> +   linker, is responsible for preserving them across the access.  */
> +
> +#define INIT_TLSDESC_CALL()						\
> +  register unsigned long tlsdesc_gp_a1 asm ("a1") = 11;			\
> +  register unsigned long tlsdesc_gp_a2 asm ("a2") = 12;			\
> +  register unsigned long tlsdesc_gp_a3 asm ("a3") = 13;			\
> +  register unsigned long tlsdesc_gp_a4 asm ("a4") = 14;			\
> +  register unsigned long tlsdesc_gp_a5 asm ("a5") = 15;			\
> +  register unsigned long tlsdesc_gp_a6 asm ("a6") = 16;			\
> +  register unsigned long tlsdesc_gp_a7 asm ("a7") = 17;			\
> +  register unsigned long tlsdesc_gp_t1 asm ("t1") = 21;			\
> +  register unsigned long tlsdesc_gp_t2 asm ("t2") = 22;			\
> +  register unsigned long tlsdesc_gp_t3 asm ("t3") = 23;			\
> +  register unsigned long tlsdesc_gp_t4 asm ("t4") = 24;			\
> +  register unsigned long tlsdesc_gp_t5 asm ("t5") = 25;			\
> +  register unsigned long tlsdesc_gp_t6 asm ("t6") = 26;
> +
> +#define LOAD_REGISTER_GP()						\
> +  asm volatile (""							\
> +		: "+r" (tlsdesc_gp_a1), "+r" (tlsdesc_gp_a2),		\
> +		  "+r" (tlsdesc_gp_a3), "+r" (tlsdesc_gp_a4),		\
> +		  "+r" (tlsdesc_gp_a5), "+r" (tlsdesc_gp_a6),		\
> +		  "+r" (tlsdesc_gp_a7), "+r" (tlsdesc_gp_t1),		\
> +		  "+r" (tlsdesc_gp_t2), "+r" (tlsdesc_gp_t3),		\
> +		  "+r" (tlsdesc_gp_t4), "+r" (tlsdesc_gp_t5),		\
> +		  "+r" (tlsdesc_gp_t6)				\
> +		:							\
> +		: "memory")
> +
> +#define SAVE_REGISTER_GP()						\
> +  LOAD_REGISTER_GP ();							\
> +  if (tlsdesc_gp_a1 != 11 || tlsdesc_gp_a2 != 12			\
> +      || tlsdesc_gp_a3 != 13 || tlsdesc_gp_a4 != 14			\
> +      || tlsdesc_gp_a5 != 15 || tlsdesc_gp_a6 != 16			\
> +      || tlsdesc_gp_a7 != 17 || tlsdesc_gp_t1 != 21			\
> +      || tlsdesc_gp_t2 != 22 || tlsdesc_gp_t3 != 23			\
> +      || tlsdesc_gp_t4 != 24 || tlsdesc_gp_t5 != 25			\
> +      || tlsdesc_gp_t6 != 26)						\
> +    {									\
> +      printf ("GP registers compare failed!\n");			\
> +      abort ();								\
> +    }
> +
> +#define CLOBBER_REGISTER_GP()						\
> +  asm volatile ("li a1, 101" ::: "a1");					\
> +  asm volatile ("li a2, 102" ::: "a2");					\
> +  asm volatile ("li a3, 103" ::: "a3");					\
> +  asm volatile ("li a4, 104" ::: "a4");					\
> +  asm volatile ("li a5, 105" ::: "a5");					\
> +  asm volatile ("li a6, 106" ::: "a6");					\
> +  asm volatile ("li a7, 107" ::: "a7");					\
> +  asm volatile ("li t1, 111" ::: "t1");					\
> +  asm volatile ("li t2, 112" ::: "t2");					\
> +  asm volatile ("li t3, 113" ::: "t3");					\
> +  asm volatile ("li t4, 114" ::: "t4");					\
> +  asm volatile ("li t5, 115" ::: "t5");					\
> +  asm volatile ("li t6, 116" ::: "t6")
> +
> +#ifndef __riscv_float_abi_soft
> +
> +# define LOAD_REGISTER_FLOAT()						\
> +  double src_float[20];							\
> +  for (int i = 0; i < 20; i++)						\
> +    src_float[i] = i + 1;						\
> +  asm volatile ("fld ft0,  %0" :: "m" (src_float[0])  : "ft0");		\
> +  asm volatile ("fld ft1,  %0" :: "m" (src_float[1])  : "ft1");		\
> +  asm volatile ("fld ft2,  %0" :: "m" (src_float[2])  : "ft2");		\
> +  asm volatile ("fld ft3,  %0" :: "m" (src_float[3])  : "ft3");		\
> +  asm volatile ("fld ft4,  %0" :: "m" (src_float[4])  : "ft4");		\
> +  asm volatile ("fld ft5,  %0" :: "m" (src_float[5])  : "ft5");		\
> +  asm volatile ("fld ft6,  %0" :: "m" (src_float[6])  : "ft6");		\
> +  asm volatile ("fld ft7,  %0" :: "m" (src_float[7])  : "ft7");		\
> +  asm volatile ("fld fa0,  %0" :: "m" (src_float[8])  : "fa0");		\
> +  asm volatile ("fld fa1,  %0" :: "m" (src_float[9])  : "fa1");		\
> +  asm volatile ("fld fa2,  %0" :: "m" (src_float[10]) : "fa2");		\
> +  asm volatile ("fld fa3,  %0" :: "m" (src_float[11]) : "fa3");		\
> +  asm volatile ("fld fa4,  %0" :: "m" (src_float[12]) : "fa4");		\
> +  asm volatile ("fld fa5,  %0" :: "m" (src_float[13]) : "fa5");		\
> +  asm volatile ("fld fa6,  %0" :: "m" (src_float[14]) : "fa6");		\
> +  asm volatile ("fld fa7,  %0" :: "m" (src_float[15]) : "fa7");		\
> +  asm volatile ("fld ft8,  %0" :: "m" (src_float[16]) : "ft8");		\
> +  asm volatile ("fld ft9,  %0" :: "m" (src_float[17]) : "ft9");		\
> +  asm volatile ("fld ft10, %0" :: "m" (src_float[18]) : "ft10");		\
> +  asm volatile ("fld ft11, %0" :: "m" (src_float[19]) : "ft11");
> +
> +# define SAVE_REGISTER_FLOAT()						\
> +  double restore_float[20];						\
> +  asm volatile ("fsd ft0,  %0" : "=m" (restore_float[0]));		\
> +  asm volatile ("fsd ft1,  %0" : "=m" (restore_float[1]));		\
> +  asm volatile ("fsd ft2,  %0" : "=m" (restore_float[2]));		\
> +  asm volatile ("fsd ft3,  %0" : "=m" (restore_float[3]));		\
> +  asm volatile ("fsd ft4,  %0" : "=m" (restore_float[4]));		\
> +  asm volatile ("fsd ft5,  %0" : "=m" (restore_float[5]));		\
> +  asm volatile ("fsd ft6,  %0" : "=m" (restore_float[6]));		\
> +  asm volatile ("fsd ft7,  %0" : "=m" (restore_float[7]));		\
> +  asm volatile ("fsd fa0,  %0" : "=m" (restore_float[8]));		\
> +  asm volatile ("fsd fa1,  %0" : "=m" (restore_float[9]));		\
> +  asm volatile ("fsd fa2,  %0" : "=m" (restore_float[10]));		\
> +  asm volatile ("fsd fa3,  %0" : "=m" (restore_float[11]));		\
> +  asm volatile ("fsd fa4,  %0" : "=m" (restore_float[12]));		\
> +  asm volatile ("fsd fa5,  %0" : "=m" (restore_float[13]));		\
> +  asm volatile ("fsd fa6,  %0" : "=m" (restore_float[14]));		\
> +  asm volatile ("fsd fa7,  %0" : "=m" (restore_float[15]));		\
> +  asm volatile ("fsd ft8,  %0" : "=m" (restore_float[16]));		\
> +  asm volatile ("fsd ft9,  %0" : "=m" (restore_float[17]));		\
> +  asm volatile ("fsd ft10, %0" : "=m" (restore_float[18]));		\
> +  asm volatile ("fsd ft11, %0" : "=m" (restore_float[19]));		\
> +  if (memcmp (src_float, restore_float, sizeof (src_float)) != 0)	\
> +    {									\
> +      printf ("Float registers compare failed!\n");			\
> +      abort ();								\
> +    }
> +
> +/* Clobber the caller-saved floating-point registers inside malloc, which is
> +   reached through __tls_get_addr on the TLSDESC slow path.  If the resolver
> +   fails to save and restore them, the sentinels planted by
> +   BEFORE_TLSDESC_CALL will be corrupted and AFTER_TLSDESC_CALL will abort.  */
> +# define PREPARE_MALLOC()						\
> +{									\
> +  static const double clobber_float[20] =				\
> +    { 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,			\
> +      111, 112, 113, 114, 115, 116, 117, 118, 119, 120 };		\
> +  CLOBBER_REGISTER_GP ();						\
> +  asm volatile ("fld ft0,  %0" :: "m" (clobber_float[0])  : "ft0");	\
> +  asm volatile ("fld ft1,  %0" :: "m" (clobber_float[1])  : "ft1");	\
> +  asm volatile ("fld ft2,  %0" :: "m" (clobber_float[2])  : "ft2");	\
> +  asm volatile ("fld ft3,  %0" :: "m" (clobber_float[3])  : "ft3");	\
> +  asm volatile ("fld ft4,  %0" :: "m" (clobber_float[4])  : "ft4");	\
> +  asm volatile ("fld ft5,  %0" :: "m" (clobber_float[5])  : "ft5");	\
> +  asm volatile ("fld ft6,  %0" :: "m" (clobber_float[6])  : "ft6");	\
> +  asm volatile ("fld ft7,  %0" :: "m" (clobber_float[7])  : "ft7");	\
> +  asm volatile ("fld fa0,  %0" :: "m" (clobber_float[8])  : "fa0");	\
> +  asm volatile ("fld fa1,  %0" :: "m" (clobber_float[9])  : "fa1");	\
> +  asm volatile ("fld fa2,  %0" :: "m" (clobber_float[10]) : "fa2");	\
> +  asm volatile ("fld fa3,  %0" :: "m" (clobber_float[11]) : "fa3");	\
> +  asm volatile ("fld fa4,  %0" :: "m" (clobber_float[12]) : "fa4");	\
> +  asm volatile ("fld fa5,  %0" :: "m" (clobber_float[13]) : "fa5");	\
> +  asm volatile ("fld fa6,  %0" :: "m" (clobber_float[14]) : "fa6");	\
> +  asm volatile ("fld fa7,  %0" :: "m" (clobber_float[15]) : "fa7");	\
> +  asm volatile ("fld ft8,  %0" :: "m" (clobber_float[16]) : "ft8");	\
> +  asm volatile ("fld ft9,  %0" :: "m" (clobber_float[17]) : "ft9");	\
> +  asm volatile ("fld ft10, %0" :: "m" (clobber_float[18]) : "ft10");	\
> +  asm volatile ("fld ft11, %0" :: "m" (clobber_float[19]) : "ft11");	\
> +}
> +
> +# define BEFORE_TLSDESC_CALL()						\
> +  LOAD_REGISTER_GP ();							\
> +  LOAD_REGISTER_FLOAT ()
> +
> +# define AFTER_TLSDESC_CALL()						\
> +  SAVE_REGISTER_GP ();							\
> +  SAVE_REGISTER_FLOAT ()
> +
> +#else /* __riscv_float_abi_soft */
> +
> +# define PREPARE_MALLOC()						\
> +  CLOBBER_REGISTER_GP ()
> +
> +# define BEFORE_TLSDESC_CALL()						\
> +  LOAD_REGISTER_GP ()
> +
> +# define AFTER_TLSDESC_CALL()						\
> +  SAVE_REGISTER_GP ()
> +
> +#endif /* __riscv_float_abi_soft */
> +
> +#include_next <tst-gnu2-tls2.h>
> 


-- 
PD Dr. Andreas K. Hüttel
[email protected]
Gentoo Linux developer 
(council, comrel, toolchain, base-system, perl, libreoffice)
https://wiki.gentoo.org/wiki/User:Dilfridge
signature.asc (application/pgp-signature, 870 B)