[PATCH 1/2] LoongArch: Fix LD_AUDIT in _dl_runtime_profile

Deng Jianbo dengjianbo@loongson.cn
Tue Nov 17 11:00:45 GMT 2026


When an audit module requests additional stack space by returning a
positive framesizep from la_loongarch_gnu_pltenter, _dl_runtime_profile
crashes for the following reasons:
  * Return values are stored starting at OFFSET_SAVED_CALL_A0 instead of
    OFFSET_RV, overwriting the saved link_map argument later passed to
    _dl_audit_pltexit and causing invalid memory accesses.
  * The caller return address is not saved in lr_ra, so the frame-growth
    path returns through an uninitialized address.
  * The saved frame pointer is stored over itself with REG_S instead of
    being restored with REG_L.

Store return values at the correct La_loongarch_retval offsets so they
do not overwrite the saved link_map and relocation-index arguments
passed to _dl_audit_pltexit. Save lr_sp and lr_ra in La_loongarch_regs
before invoking the audit callbacks, and restore fp with REG_L. Because
La_loongarch_vector is a 32-byte slot in LASX, LSX, and scalar
floating-point modes, use a 32-byte stride when storing or loading LSX
and scalar floating-point registers.
---
 sysdeps/loongarch/Makefile         |  14 ++
 sysdeps/loongarch/dl-trampoline.h  | 133 +++++------
 sysdeps/loongarch/tst-audit29.c    | 155 +++++++++++++
 sysdeps/loongarch/tst-audit29mod.c | 198 ++++++++++++++++
 sysdeps/loongarch/tst-audit29mod.h | 162 +++++++++++++
 sysdeps/loongarch/tst-auditmod29.c | 352 +++++++++++++++++++++++++++++
 6 files changed, 951 insertions(+), 63 deletions(-)
 create mode 100644 sysdeps/loongarch/tst-audit29.c
 create mode 100644 sysdeps/loongarch/tst-audit29mod.c
 create mode 100644 sysdeps/loongarch/tst-audit29mod.h
 create mode 100644 sysdeps/loongarch/tst-auditmod29.c

diff --git a/sysdeps/loongarch/Makefile b/sysdeps/loongarch/Makefile
index 5818755f05..074d29dd48 100644
--- a/sysdeps/loongarch/Makefile
+++ b/sysdeps/loongarch/Makefile
@@ -20,6 +20,20 @@ gen-as-const-headers += \
   dl-link.sym \
   # gen-as-const-headers
 
+tests += \
+  tst-audit29 \
+  # tests
+
+modules-names += \
+  tst-audit29mod \
+  tst-auditmod29 \
+  # modules-names
+
+$(objpfx)tst-audit29: $(objpfx)tst-audit29mod.so $(objpfx)tst-auditmod29.so
+$(objpfx)tst-audit29mod.so: $(libsupport)
+LDFLAGS-tst-audit29 += -Wl,-z,lazy
+tst-audit29-ENV = LD_AUDIT=$(objpfx)tst-auditmod29.so
+
 CFLAGS-tst-tunables-seal.c += -DTST_SEAL_TUNABLE_NAME=hwcaps
 tst-tunables-seal-TUNABLES += glibc.cpu.hwcaps=-LASX
 endif
diff --git a/sysdeps/loongarch/dl-trampoline.h b/sysdeps/loongarch/dl-trampoline.h
index 578ed8600a..9285a7e646 100644
--- a/sysdeps/loongarch/dl-trampoline.h
+++ b/sysdeps/loongarch/dl-trampoline.h
@@ -183,25 +183,32 @@ ENTRY (_dl_runtime_profile)
 	xvst	xr6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZXREG
 	xvst	xr7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZXREG
 #elif defined USE_LSX
-	vst	vr0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZVREG
-	vst	vr1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZVREG
-	vst	vr2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZVREG
-	vst	vr3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZVREG
-	vst	vr4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZVREG
-	vst	vr5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZVREG
-	vst	vr6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZVREG
-	vst	vr7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZVREG
+	/* A La_loongarch_vector slot is 32 bytes even in LSX mode, so advance
+	   one full slot for each vector register.  */
+	vst	vr0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZXREG
+	vst	vr1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZXREG
+	vst	vr2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZXREG
+	vst	vr3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZXREG
+	vst	vr4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZXREG
+	vst	vr5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZXREG
+	vst	vr6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZXREG
+	vst	vr7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZXREG
 #elif !defined __loongarch_soft_float
-	FREG_S	fa0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZFREG
-	FREG_S	fa1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZFREG
-	FREG_S	fa2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZFREG
-	FREG_S	fa3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZFREG
-	FREG_S	fa4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZFREG
-	FREG_S	fa5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZFREG
-	FREG_S	fa6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZFREG
-	FREG_S	fa7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZFREG
+	FREG_S	fa0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZXREG
+	FREG_S	fa1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZXREG
+	FREG_S	fa2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZXREG
+	FREG_S	fa3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZXREG
+	FREG_S	fa4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZXREG
+	FREG_S	fa5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZXREG
+	FREG_S	fa6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZXREG
+	FREG_S	fa7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZXREG
 #endif
 
+	/* Record the caller's stack pointer and return address for audit.  */
+	ADDI	a0, sp, SF_SIZE
+	REG_S	a0, fp, OFFSET_RG + DL_OFFSET_RG_SP
+	REG_S	ra, fp, OFFSET_RG + DL_OFFSET_RG_RA
+
 	/* Update .got.plt and obtain runtime address of callee.  */
 	SLLI	a1, t1, 1
 	or	a0, t0, zero
@@ -242,23 +249,23 @@ ENTRY (_dl_runtime_profile)
 	xvld	xr6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZXREG
 	xvld	xr7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZXREG
 #elif defined USE_LSX
-	vld	vr0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZVREG
-	vld	vr1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZVREG
-	vld	vr2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZVREG
-	vld	vr3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZVREG
-	vld	vr4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZVREG
-	vld	vr5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZVREG
-	vld	vr6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZVREG
-	vld	vr7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZVREG
+	vld	vr0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZXREG
+	vld	vr1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZXREG
+	vld	vr2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZXREG
+	vld	vr3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZXREG
+	vld	vr4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZXREG
+	vld	vr5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZXREG
+	vld	vr6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZXREG
+	vld	vr7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZXREG
 #elif !defined __loongarch_soft_float
-	FREG_L	fa0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZFREG
-	FREG_L	fa1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZFREG
-	FREG_L	fa2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZFREG
-	FREG_L	fa3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZFREG
-	FREG_L	fa4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZFREG
-	FREG_L	fa5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZFREG
-	FREG_L	fa6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZFREG
-	FREG_L	fa7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZFREG
+	FREG_L	fa0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZXREG
+	FREG_L	fa1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZXREG
+	FREG_L	fa2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZXREG
+	FREG_L	fa3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZXREG
+	FREG_L	fa4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZXREG
+	FREG_L	fa5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZXREG
+	FREG_L	fa6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZXREG
+	FREG_L	fa7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZXREG
 #endif
 
 	REG_L   ra, fp, 0
@@ -302,39 +309,39 @@ ENTRY (_dl_runtime_profile)
 	xvld	xr6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZXREG
 	xvld	xr7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZXREG
 #elif defined USE_LSX
-	vld	vr0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZVREG
-	vld	vr1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZVREG
-	vld	vr2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZVREG
-	vld	vr3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZVREG
-	vld	vr4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZVREG
-	vld	vr5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZVREG
-	vld	vr6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZVREG
-	vld	vr7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZVREG
+	vld	vr0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZXREG
+	vld	vr1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZXREG
+	vld	vr2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZXREG
+	vld	vr3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZXREG
+	vld	vr4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZXREG
+	vld	vr5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZXREG
+	vld	vr6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZXREG
+	vld	vr7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZXREG
 #elif !defined __loongarch_soft_float
-	FREG_L	fa0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZFREG
-	FREG_L	fa1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZFREG
-	FREG_L	fa2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZFREG
-	FREG_L	fa3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZFREG
-	FREG_L	fa4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZFREG
-	FREG_L	fa5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZFREG
-	FREG_L	fa6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZFREG
-	FREG_L	fa7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZFREG
+	FREG_L	fa0, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 0*SZXREG
+	FREG_L	fa1, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 1*SZXREG
+	FREG_L	fa2, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 2*SZXREG
+	FREG_L	fa3, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 3*SZXREG
+	FREG_L	fa4, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 4*SZXREG
+	FREG_L	fa5, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 5*SZXREG
+	FREG_L	fa6, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 6*SZXREG
+	FREG_L	fa7, fp, OFFSET_RG + DL_OFFSET_RG_VEC0 + 7*SZXREG
 #endif
 
 	jirl	ra, t6, 0
 
-	REG_S	a0, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_A0
-	REG_S	a1, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_A0 + SZREG
+	REG_S	a0, fp, OFFSET_RV + DL_OFFSET_RV_A0
+	REG_S	a1, fp, OFFSET_RV + DL_OFFSET_RV_A0 + SZREG
 
 #ifdef USE_LASX
-	xvst	xr0, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0
-	xvst	xr1, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0 + SZXREG
+	xvst	xr0, fp, OFFSET_RV + DL_OFFSET_RV_VEC0
+	xvst	xr1, fp, OFFSET_RV + DL_OFFSET_RV_VEC0 + SZXREG
 #elif defined USE_LSX
-	vst	vr0, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0
-	vst	vr1, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0 + SZVREG
+	vst	vr0, fp, OFFSET_RV + DL_OFFSET_RV_VEC0
+	vst	vr1, fp, OFFSET_RV + DL_OFFSET_RV_VEC0 + SZXREG
 #elif !defined __loongarch_soft_float
-	FREG_S	fa0, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0
-	FREG_S	fa1, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0 + SZFREG
+	FREG_S	fa0, fp, OFFSET_RV + DL_OFFSET_RV_VEC0
+	FREG_S	fa1, fp, OFFSET_RV + DL_OFFSET_RV_VEC0 + SZXREG
 #endif
 
 	/* Setup call to pltexit.  */
@@ -349,21 +356,21 @@ ENTRY (_dl_runtime_profile)
 	REG_L	a1, fp, OFFSET_RV + DL_OFFSET_RV_A0 + SZREG
 
 #ifdef USE_LASX
-	xvld	xr0, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0
-	xvld	xr1, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0 + SZXREG
+	xvld	xr0, fp, OFFSET_RV + DL_OFFSET_RV_VEC0
+	xvld	xr1, fp, OFFSET_RV + DL_OFFSET_RV_VEC0 + SZXREG
 #elif defined USE_LSX
-	vld	vr0, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0
-	vld	vr1, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0 + SZVREG
+	vld	vr0, fp, OFFSET_RV + DL_OFFSET_RV_VEC0
+	vld	vr1, fp, OFFSET_RV + DL_OFFSET_RV_VEC0 + SZXREG
 #elif !defined __loongarch_soft_float
-	FREG_L	fa0, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0
-	FREG_L	fa1, fp, OFFSET_SAVED_CALL_A0 + DL_OFFSET_RV_VEC0 + SZFREG
+	FREG_L	fa0, fp, OFFSET_RV + DL_OFFSET_RV_VEC0
+	FREG_L	fa1, fp, OFFSET_RV + DL_OFFSET_RV_VEC0 + SZXREG
 #endif
 
 	/* RA from within La_loongarch_reg.  */
 	REG_L   ra, fp, OFFSET_RG + DL_OFFSET_RG_RA
 	or	sp, fp, zero
 	ADDI	sp, sp, SF_SIZE
-	REG_S   fp, fp, SZREG
+	REG_L   fp, fp, SZREG
 
 	jirl	zero, ra, 0
 
diff --git a/sysdeps/loongarch/tst-audit29.c b/sysdeps/loongarch/tst-audit29.c
new file mode 100644
index 0000000000..b79d5184c2
--- /dev/null
+++ b/sysdeps/loongarch/tst-audit29.c
@@ -0,0 +1,155 @@
+/* Check LD_AUDIT for LoongArch ABI specifics.
+   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 <support/check.h>
+#include "tst-audit29mod.h"
+
+int
+do_test (void)
+{
+  {
+    int r = tst_audit29_func_int (FUNC_INT_ARG0, FUNC_INT_ARG1, FUNC_INT_ARG2,
+				  FUNC_INT_ARG3, FUNC_INT_ARG4, FUNC_INT_ARG5,
+				  FUNC_INT_ARG6, FUNC_INT_ARG7);
+    if (r != FUNC_INT_RET)
+      FAIL_EXIT1 ("tst_audit29_func_int returned %d, expected %d", r,
+		  FUNC_INT_RET);
+  }
+
+  {
+    long int r = tst_audit29_func_long (FUNC_LONG_ARG0, FUNC_LONG_ARG1,
+					FUNC_LONG_ARG2, FUNC_LONG_ARG3,
+					FUNC_LONG_ARG4, FUNC_LONG_ARG5,
+					FUNC_LONG_ARG6, FUNC_LONG_ARG7);
+    if (r != FUNC_LONG_RET)
+      FAIL_EXIT1 ("tst_audit29_func_long returned %ld, expected %ld", r,
+		  FUNC_LONG_RET);
+  }
+
+  {
+    /* Arguments a8 through a11 are passed on the caller stack.  The audit
+       module also inspects them through lr_sp in pltexit.  */
+    long int r = tst_audit29_func_stack_long (
+      FUNC_LONG_ARG0, FUNC_LONG_ARG1, FUNC_LONG_ARG2,
+      FUNC_LONG_ARG3, FUNC_LONG_ARG4, FUNC_LONG_ARG5,
+      FUNC_LONG_ARG6, FUNC_LONG_ARG7, FUNC_STACK_LONG_ARG8,
+      FUNC_STACK_LONG_ARG9, FUNC_STACK_LONG_ARG10, FUNC_STACK_LONG_ARG11);
+    if (r != FUNC_STACK_LONG_RET)
+      FAIL_EXIT1 ("tst_audit29_func_stack_long returned %ld, expected %ld",
+		  r, FUNC_STACK_LONG_RET);
+  }
+
+  {
+    /* The result is returned in a0 and a1.  This case checks that pltexit does
+       not change it.  */
+    struct tst_audit29_ret2 r = tst_audit29_func_ret2 ();
+    if (r.a0 != FUNC_RET2_A0 || r.a1 != FUNC_RET2_A1)
+      FAIL_EXIT1 ("tst_audit29_func_ret2 returned %ld/%ld, expected %ld/%ld",
+		  r.a0, r.a1, FUNC_RET2_A0, FUNC_RET2_A1);
+  }
+
+  {
+    /* pltexit rewrites both return registers.  Receiving the modified values
+       here proves that the trampoline reloaded outregs after the callback.  */
+    struct tst_audit29_ret2 r = tst_audit29_func_ret2_modified ();
+    if (r.a0 != FUNC_RET2_A0_MODIFIED || r.a1 != FUNC_RET2_A1_MODIFIED)
+      FAIL_EXIT1 ("tst_audit29_func_ret2_modified returned %ld/%ld, "
+		  "expected %ld/%ld", r.a0, r.a1, FUNC_RET2_A0_MODIFIED,
+		  FUNC_RET2_A1_MODIFIED);
+  }
+
+  {
+    /* The return value is larger than two registers and uses a0 as the
+       caller-provided stack result buffer.  */
+    struct tst_audit29_ret_large r
+      = tst_audit29_func_ret_large (FUNC_RET_LARGE_ARG0, FUNC_RET_LARGE_ARG1,
+				    FUNC_RET_LARGE_ARG2);
+    struct tst_audit29_ret_large expected
+      = make_tst_audit29_ret_large (FUNC_RET_LARGE_ARG0, FUNC_RET_LARGE_ARG1,
+				    FUNC_RET_LARGE_ARG2);
+
+    TEST_COMPARE_BLOB (&r, sizeof (r), &expected, sizeof (expected));
+  }
+
+#ifndef __loongarch_soft_float
+  /* The audit module clobbers fa0 through fa7 after each callback.  These
+     calls pass all eight floating-point arguments in those registers and also
+     return through them, so success requires the trampoline to reload both the
+     argument and result registers.  */
+  {
+    float r = tst_audit29_func_float (FUNC_FLOAT_ARG0, FUNC_FLOAT_ARG1,
+				      FUNC_FLOAT_ARG2, FUNC_FLOAT_ARG3,
+				      FUNC_FLOAT_ARG4, FUNC_FLOAT_ARG5,
+				      FUNC_FLOAT_ARG6, FUNC_FLOAT_ARG7);
+    if (r != FUNC_FLOAT_RET)
+      FAIL_EXIT1 ("tst_audit29_func_float returned %a, expected %a", r,
+		  FUNC_FLOAT_RET);
+  }
+
+  {
+    /* The result is returned in fa0 and fa1.  This case checks that pltexit
+       does not change it.  */
+    struct tst_audit29_ret2_float r = tst_audit29_func_ret2_float ();
+    if (r.a0 != FUNC_RET2_FP_A0 || r.a1 != FUNC_RET2_FP_A1)
+      FAIL_EXIT1 ("tst_audit29_func_ret2_float returned %a/%a, expected %a/%a",
+		  r.a0, r.a1, FUNC_RET2_FP_A0, FUNC_RET2_FP_A1);
+  }
+
+  {
+    /* This case checks that pltexit rewrites the return result in fa0 and
+       fa1.  */
+    struct tst_audit29_ret2_float r = tst_audit29_func_ret2_float_modified ();
+    if (r.a0 != FUNC_RET2_FP_A0_MODIFIED || r.a1 != FUNC_RET2_FP_A1_MODIFIED)
+      FAIL_EXIT1 ("tst_audit29_func_ret2_float_modified returned %a/%a, "
+		  "expected %a/%a", r.a0, r.a1, FUNC_RET2_FP_A0_MODIFIED,
+		  FUNC_RET2_FP_A1_MODIFIED);
+  }
+#if __loongarch_frlen == 64
+  {
+    double r = tst_audit29_func_double (FUNC_DOUBLE_ARG0, FUNC_DOUBLE_ARG1,
+					FUNC_DOUBLE_ARG2, FUNC_DOUBLE_ARG3,
+					FUNC_DOUBLE_ARG4, FUNC_DOUBLE_ARG5,
+					FUNC_DOUBLE_ARG6, FUNC_DOUBLE_ARG7);
+    if (r != FUNC_DOUBLE_RET)
+      FAIL_EXIT1 ("tst_audit29_func_double returned %a, expected %a", r,
+		  FUNC_DOUBLE_RET);
+  }
+
+  {
+    struct tst_audit29_ret2_double r = tst_audit29_func_ret2_double ();
+    if (r.a0 != FUNC_RET2_FP_A0 || r.a1 != FUNC_RET2_FP_A1)
+      FAIL_EXIT1 ("tst_audit29_func_ret2_double returned %a/%a, "
+		  "expected %a/%a", r.a0, r.a1, FUNC_RET2_FP_A0,
+		  FUNC_RET2_FP_A1);
+  }
+
+  {
+    struct tst_audit29_ret2_double r
+      = tst_audit29_func_ret2_double_modified ();
+    if (r.a0 != FUNC_RET2_FP_A0_MODIFIED || r.a1 != FUNC_RET2_FP_A1_MODIFIED)
+      FAIL_EXIT1 ("tst_audit29_func_ret2_double_modified returned %a/%a, "
+		  "expected %a/%a", r.a0, r.a1, FUNC_RET2_FP_A0_MODIFIED,
+		  FUNC_RET2_FP_A1_MODIFIED);
+  }
+#endif
+#endif
+
+  return 0;
+}
+
+#include <support/test-driver.c>
diff --git a/sysdeps/loongarch/tst-audit29mod.c b/sysdeps/loongarch/tst-audit29mod.c
new file mode 100644
index 0000000000..3ffe2fadb7
--- /dev/null
+++ b/sysdeps/loongarch/tst-audit29mod.c
@@ -0,0 +1,198 @@
+/* Check LD_AUDIT for LoongArch ABI specifics.
+   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 <support/check.h>
+#include "tst-audit29mod.h"
+
+int
+tst_audit29_func_int (int a0, int a1, int a2, int a3, int a4, int a5, int a6,
+		      int a7)
+{
+  if (a0 != FUNC_INT_ARG0)
+    FAIL_EXIT1 ("a0: %d != %d", a0, FUNC_INT_ARG0);
+  if (a1 != FUNC_INT_ARG1)
+    FAIL_EXIT1 ("a1: %d != %d", a1, FUNC_INT_ARG1);
+  if (a2 != FUNC_INT_ARG2)
+    FAIL_EXIT1 ("a2: %d != %d", a2, FUNC_INT_ARG2);
+  if (a3 != FUNC_INT_ARG3)
+    FAIL_EXIT1 ("a3: %d != %d", a3, FUNC_INT_ARG3);
+  if (a4 != FUNC_INT_ARG4)
+    FAIL_EXIT1 ("a4: %d != %d", a4, FUNC_INT_ARG4);
+  if (a5 != FUNC_INT_ARG5)
+    FAIL_EXIT1 ("a5: %d != %d", a5, FUNC_INT_ARG5);
+  if (a6 != FUNC_INT_ARG6)
+    FAIL_EXIT1 ("a6: %d != %d", a6, FUNC_INT_ARG6);
+  if (a7 != FUNC_INT_ARG7)
+    FAIL_EXIT1 ("a7: %d != %d", a7, FUNC_INT_ARG7);
+
+  return FUNC_INT_RET;
+}
+
+long int
+tst_audit29_func_long (long int a0, long int a1, long int a2, long int a3,
+		       long int a4, long int a5, long int a6, long int a7)
+{
+  if (a0 != FUNC_LONG_ARG0)
+    FAIL_EXIT1 ("a0: %ld != %ld", a0, FUNC_LONG_ARG0);
+  if (a1 != FUNC_LONG_ARG1)
+    FAIL_EXIT1 ("a1: %ld != %ld", a1, FUNC_LONG_ARG1);
+  if (a2 != FUNC_LONG_ARG2)
+    FAIL_EXIT1 ("a2: %ld != %ld", a2, FUNC_LONG_ARG2);
+  if (a3 != FUNC_LONG_ARG3)
+    FAIL_EXIT1 ("a3: %ld != %ld", a3, FUNC_LONG_ARG3);
+  if (a4 != FUNC_LONG_ARG4)
+    FAIL_EXIT1 ("a4: %ld != %ld", a4, FUNC_LONG_ARG4);
+  if (a5 != FUNC_LONG_ARG5)
+    FAIL_EXIT1 ("a5: %ld != %ld", a5, FUNC_LONG_ARG5);
+  if (a6 != FUNC_LONG_ARG6)
+    FAIL_EXIT1 ("a6: %ld != %ld", a6, FUNC_LONG_ARG6);
+  if (a7 != FUNC_LONG_ARG7)
+    FAIL_EXIT1 ("a7: %ld != %ld", a7, FUNC_LONG_ARG7);
+
+  return FUNC_LONG_RET;
+}
+
+long int
+tst_audit29_func_stack_long (long int a0, long int a1, long int a2,
+			     long int a3, long int a4, long int a5,
+			     long int a6, long int a7, long int a8,
+			     long int a9, long int a10, long int a11)
+{
+  const long int actual[] = {
+    a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11
+  };
+  const long int expected[] = {
+    FUNC_LONG_ARG0, FUNC_LONG_ARG1, FUNC_LONG_ARG2,
+    FUNC_LONG_ARG3, FUNC_LONG_ARG4, FUNC_LONG_ARG5,
+    FUNC_LONG_ARG6, FUNC_LONG_ARG7, FUNC_STACK_LONG_ARG8,
+    FUNC_STACK_LONG_ARG9, FUNC_STACK_LONG_ARG10, FUNC_STACK_LONG_ARG11
+  };
+
+  for (size_t i = 0; i < sizeof (actual) / sizeof (actual[0]); ++i)
+    if (actual[i] != expected[i])
+      FAIL_EXIT1 ("a%zu: %ld != %ld", i, actual[i], expected[i]);
+
+  return FUNC_STACK_LONG_RET;
+}
+
+struct tst_audit29_ret2
+tst_audit29_func_ret2 (void)
+{
+  struct tst_audit29_ret2 ret = {FUNC_RET2_A0, FUNC_RET2_A1};
+  return ret;
+}
+
+struct tst_audit29_ret2
+tst_audit29_func_ret2_modified (void)
+{
+  struct tst_audit29_ret2 ret = {FUNC_RET2_A0, FUNC_RET2_A1};
+  return ret;
+}
+
+struct tst_audit29_ret_large
+tst_audit29_func_ret_large (char a, short b, long int c)
+{
+  if (a != FUNC_RET_LARGE_ARG0)
+    FAIL_EXIT1 ("a: %#x != %#x", a, FUNC_RET_LARGE_ARG0);
+  if (b != FUNC_RET_LARGE_ARG1)
+    FAIL_EXIT1 ("b: %#x != %#x", b, FUNC_RET_LARGE_ARG1);
+  if (c != FUNC_RET_LARGE_ARG2)
+    FAIL_EXIT1 ("c: %#lx != %#lx", c, FUNC_RET_LARGE_ARG2);
+
+  return make_tst_audit29_ret_large (a, b, c);
+}
+
+#ifndef __loongarch_soft_float
+float
+tst_audit29_func_float (float a0, float a1, float a2, float a3, float a4,
+			float a5, float a6, float a7)
+{
+  if (a0 != FUNC_FLOAT_ARG0)
+    FAIL_EXIT1 ("a0: %a != %a", a0, FUNC_FLOAT_ARG0);
+  if (a1 != FUNC_FLOAT_ARG1)
+    FAIL_EXIT1 ("a1: %a != %a", a1, FUNC_FLOAT_ARG1);
+  if (a2 != FUNC_FLOAT_ARG2)
+    FAIL_EXIT1 ("a2: %a != %a", a2, FUNC_FLOAT_ARG2);
+  if (a3 != FUNC_FLOAT_ARG3)
+    FAIL_EXIT1 ("a3: %a != %a", a3, FUNC_FLOAT_ARG3);
+  if (a4 != FUNC_FLOAT_ARG4)
+    FAIL_EXIT1 ("a4: %a != %a", a4, FUNC_FLOAT_ARG4);
+  if (a5 != FUNC_FLOAT_ARG5)
+    FAIL_EXIT1 ("a5: %a != %a", a5, FUNC_FLOAT_ARG5);
+  if (a6 != FUNC_FLOAT_ARG6)
+    FAIL_EXIT1 ("a6: %a != %a", a6, FUNC_FLOAT_ARG6);
+  if (a7 != FUNC_FLOAT_ARG7)
+    FAIL_EXIT1 ("a7: %a != %a", a7, FUNC_FLOAT_ARG7);
+
+  return FUNC_FLOAT_RET;
+}
+
+struct tst_audit29_ret2_float
+tst_audit29_func_ret2_float (void)
+{
+  struct tst_audit29_ret2_float ret = {FUNC_RET2_FP_A0, FUNC_RET2_FP_A1};
+  return ret;
+}
+
+struct tst_audit29_ret2_float
+tst_audit29_func_ret2_float_modified (void)
+{
+  struct tst_audit29_ret2_float ret = {FUNC_RET2_FP_A0, FUNC_RET2_FP_A1};
+  return ret;
+}
+
+#if __loongarch_frlen == 64
+double
+tst_audit29_func_double (double a0, double a1, double a2, double a3, double a4,
+			 double a5, double a6, double a7)
+{
+  if (a0 != FUNC_DOUBLE_ARG0)
+    FAIL_EXIT1 ("a0: %a != %a", a0, FUNC_DOUBLE_ARG0);
+  if (a1 != FUNC_DOUBLE_ARG1)
+    FAIL_EXIT1 ("a1: %a != %a", a1, FUNC_DOUBLE_ARG1);
+  if (a2 != FUNC_DOUBLE_ARG2)
+    FAIL_EXIT1 ("a2: %a != %a", a2, FUNC_DOUBLE_ARG2);
+  if (a3 != FUNC_DOUBLE_ARG3)
+    FAIL_EXIT1 ("a3: %a != %a", a3, FUNC_DOUBLE_ARG3);
+  if (a4 != FUNC_DOUBLE_ARG4)
+    FAIL_EXIT1 ("a4: %a != %a", a4, FUNC_DOUBLE_ARG4);
+  if (a5 != FUNC_DOUBLE_ARG5)
+    FAIL_EXIT1 ("a5: %a != %a", a5, FUNC_DOUBLE_ARG5);
+  if (a6 != FUNC_DOUBLE_ARG6)
+    FAIL_EXIT1 ("a6: %a != %a", a6, FUNC_DOUBLE_ARG6);
+  if (a7 != FUNC_DOUBLE_ARG7)
+    FAIL_EXIT1 ("a7: %a != %a", a7, FUNC_DOUBLE_ARG7);
+
+  return FUNC_DOUBLE_RET;
+}
+
+struct tst_audit29_ret2_double
+tst_audit29_func_ret2_double (void)
+{
+  struct tst_audit29_ret2_double ret = {FUNC_RET2_FP_A0, FUNC_RET2_FP_A1};
+  return ret;
+}
+
+struct tst_audit29_ret2_double
+tst_audit29_func_ret2_double_modified (void)
+{
+  struct tst_audit29_ret2_double ret = {FUNC_RET2_FP_A0, FUNC_RET2_FP_A1};
+  return ret;
+}
+#endif
+#endif
diff --git a/sysdeps/loongarch/tst-audit29mod.h b/sysdeps/loongarch/tst-audit29mod.h
new file mode 100644
index 0000000000..d4a7ed900d
--- /dev/null
+++ b/sysdeps/loongarch/tst-audit29mod.h
@@ -0,0 +1,162 @@
+/* Check LD_AUDIT for LoongArch ABI specifics.
+   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 _TST_AUDIT29MOD_H
+#define _TST_AUDIT29MOD_H 1
+
+#include <array_length.h>
+#include <float.h>
+#include <limits.h>
+
+#define FUNC_INT_ARG0 INT_MIN
+#define FUNC_INT_ARG1 INT_MAX
+#define FUNC_INT_ARG2 -1
+#define FUNC_INT_ARG3 0
+#define FUNC_INT_ARG4 1
+#define FUNC_INT_ARG5 2
+#define FUNC_INT_ARG6 3
+#define FUNC_INT_ARG7 4
+#define FUNC_INT_RET  5
+
+int
+tst_audit29_func_int (int a0, int a1, int a2, int a3, int a4, int a5, int a6,
+		      int a7);
+
+#define FUNC_LONG_ARG0 LONG_MIN
+#define FUNC_LONG_ARG1 LONG_MAX
+#define FUNC_LONG_ARG2 -1L
+#define FUNC_LONG_ARG3 0L
+#define FUNC_LONG_ARG4 1L
+#define FUNC_LONG_ARG5 2L
+#define FUNC_LONG_ARG6 3L
+#define FUNC_LONG_ARG7 4L
+#define FUNC_LONG_RET  5L
+
+#define FUNC_STACK_LONG_ARG8 1008L
+#define FUNC_STACK_LONG_ARG9 1009L
+#define FUNC_STACK_LONG_ARG10 1010L
+#define FUNC_STACK_LONG_ARG11 1011L
+#define FUNC_STACK_LONG_RET 1012L
+
+long int
+tst_audit29_func_long (long int a0, long int a1, long int a2, long int a3,
+		       long int a4, long int a5, long int a6, long int a7);
+
+long int
+tst_audit29_func_stack_long (long int a0, long int a1, long int a2,
+			     long int a3, long int a4, long int a5,
+			     long int a6, long int a7, long int a8,
+			     long int a9, long int a10, long int a11);
+
+struct tst_audit29_ret2
+{
+  long int a0;
+  long int a1;
+};
+
+#define FUNC_RET2_A0 LONG_MIN
+#define FUNC_RET2_A1 LONG_MAX
+#define FUNC_RET2_A0_MODIFIED 0x12345678L
+#define FUNC_RET2_A1_MODIFIED 0x9abcdef0L
+
+struct tst_audit29_ret2 tst_audit29_func_ret2 (void);
+struct tst_audit29_ret2 tst_audit29_func_ret2_modified (void);
+
+struct tst_audit29_ret_large
+{
+  char a[16];
+  short b[8];
+  long int c[4];
+};
+
+static inline struct tst_audit29_ret_large
+make_tst_audit29_ret_large (char a, short b, long int c)
+{
+  struct tst_audit29_ret_large r;
+
+  for (int i = 0; i < array_length (r.a); ++i)
+    r.a[i] = a;
+  for (int i = 0; i < array_length (r.b); ++i)
+    r.b[i] = b;
+  for (int i = 0; i < array_length (r.c); ++i)
+    r.c[i] = c;
+  return r;
+}
+
+#define FUNC_RET_LARGE_ARG0 0x12
+#define FUNC_RET_LARGE_ARG1 0x1234
+#define FUNC_RET_LARGE_ARG2 0x12345678L
+
+struct tst_audit29_ret_large
+tst_audit29_func_ret_large (char a, short b, long int c);
+
+#ifndef __loongarch_soft_float
+
+#define FUNC_FLOAT_ARG0 FLT_MIN
+#define FUNC_FLOAT_ARG1 FLT_MAX
+#define FUNC_FLOAT_ARG2 FLT_EPSILON
+#define FUNC_FLOAT_ARG3 FLT_TRUE_MIN
+#define FUNC_FLOAT_ARG4 0.0f
+#define FUNC_FLOAT_ARG5 1.0f
+#define FUNC_FLOAT_ARG6 2.0f
+#define FUNC_FLOAT_ARG7 3.0f
+#define FUNC_FLOAT_RET  4.0f
+
+#define FUNC_RET2_FP_A0 1.25
+#define FUNC_RET2_FP_A1 -2.5
+#define FUNC_RET2_FP_A0_MODIFIED 3.5
+#define FUNC_RET2_FP_A1_MODIFIED -6.75
+
+float
+tst_audit29_func_float (float a0, float a1, float a2, float a3, float a4,
+			float a5, float a6, float a7);
+
+struct tst_audit29_ret2_float
+{
+  float a0;
+  float a1;
+};
+
+struct tst_audit29_ret2_float tst_audit29_func_ret2_float (void);
+struct tst_audit29_ret2_float tst_audit29_func_ret2_float_modified (void);
+
+#if __loongarch_frlen == 64
+#define FUNC_DOUBLE_ARG0 DBL_MIN
+#define FUNC_DOUBLE_ARG1 DBL_MAX
+#define FUNC_DOUBLE_ARG2 DBL_EPSILON
+#define FUNC_DOUBLE_ARG3 DBL_TRUE_MIN
+#define FUNC_DOUBLE_ARG4 0.0
+#define FUNC_DOUBLE_ARG5 1.0
+#define FUNC_DOUBLE_ARG6 2.0
+#define FUNC_DOUBLE_ARG7 3.0
+#define FUNC_DOUBLE_RET  0x1.fffffe0000001p+127
+
+struct tst_audit29_ret2_double
+{
+  double a0;
+  double a1;
+};
+
+struct tst_audit29_ret2_double tst_audit29_func_ret2_double (void);
+struct tst_audit29_ret2_double tst_audit29_func_ret2_double_modified (void);
+double
+tst_audit29_func_double (double a0, double a1, double a2, double a3, double a4,
+			 double a5, double a6, double a7);
+#endif
+#endif
+#endif
diff --git a/sysdeps/loongarch/tst-auditmod29.c b/sysdeps/loongarch/tst-auditmod29.c
new file mode 100644
index 0000000000..0125236061
--- /dev/null
+++ b/sysdeps/loongarch/tst-auditmod29.c
@@ -0,0 +1,352 @@
+/* Check LD_AUDIT for LoongArch ABI specifics.
+   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 <assert.h>
+#include <link.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/asm.h>
+#include "tst-audit29mod.h"
+
+#define TEST_NAME  "tst-audit29"
+
+#define AUDIT29_COOKIE 0
+
+#ifndef __loongarch_soft_float
+static float
+fpreg_float (const La_loongarch_vector *v)
+{
+  float value;
+  memcpy (&value, v, sizeof (value));
+  return value;
+}
+
+static void
+set_fpreg_float (La_loongarch_vector *v, float value)
+{
+  memcpy (v, &value, sizeof (value));
+}
+
+#if __loongarch_frlen == 64
+static double
+fpreg_double (const La_loongarch_vector *v)
+{
+  return v->fpreg[0];
+}
+
+static void
+set_fpreg_double (La_loongarch_vector *v, double value)
+{
+  v->fpreg[0] = value;
+}
+#endif
+
+static void
+clobber_fp_regs (void)
+{
+#define STRINGXP(X) __STRING (X)
+  const double clobber = -1.0;
+  asm volatile (STRINGXP (FREG_L) " $f0, %0\n\t"
+		STRINGXP (FREG_L) " $f1, %0\n\t"
+		STRINGXP (FREG_L) " $f2, %0\n\t"
+		STRINGXP (FREG_L) " $f3, %0\n\t"
+		STRINGXP (FREG_L) " $f4, %0\n\t"
+		STRINGXP (FREG_L) " $f5, %0\n\t"
+		STRINGXP (FREG_L) " $f6, %0\n\t"
+		STRINGXP (FREG_L) " $f7, %0"
+		: : "m" (clobber)
+		: "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7");
+#undef STRINGXP
+}
+#endif
+
+static void
+check_stack_long_args (const La_loongarch_regs *regs)
+{
+  const long int *stack_args = (const long int *) regs->lr_sp;
+
+  assert (stack_args[0] == FUNC_STACK_LONG_ARG8);
+  assert (stack_args[1] == FUNC_STACK_LONG_ARG9);
+  assert (stack_args[2] == FUNC_STACK_LONG_ARG10);
+  assert (stack_args[3] == FUNC_STACK_LONG_ARG11);
+}
+
+unsigned int
+la_version (unsigned int v)
+{
+  setlinebuf (stdout);
+  return v;
+}
+
+unsigned int
+la_objopen (struct link_map *map, Lmid_t lmid, uintptr_t *cookie)
+{
+  const char *p = strrchr (map->l_name, '/');
+  const char *l_name = p == NULL ? map->l_name : p + 1;
+  uintptr_t ck = -1;
+  if (l_name[0] == '\0'
+      || strncmp (l_name, TEST_NAME, strlen (TEST_NAME)) == 0)
+    ck = AUDIT29_COOKIE;
+  *cookie = ck;
+  printf ("objopen: %ld, %s[%ld]\n", lmid, l_name, (long int) ck);
+  return ck == -1 ? 0 : LA_FLG_BINDFROM | LA_FLG_BINDTO;
+}
+
+ElfW (Addr)
+la_loongarch_gnu_pltenter (ElfW (Sym) *sym, unsigned int ndx,
+			   uintptr_t *refcook, uintptr_t *defcook,
+			   La_loongarch_regs *regs, unsigned int *flags,
+			   const char *symname, long int *framesizep)
+{
+  printf ("pltenter: symname=%s, st_value=%#lx, ndx=%u, flags=%u\n",
+	  symname, (long int) sym->st_value, ndx, *flags);
+
+  if (strcmp (symname, "tst_audit29_func_int") == 0)
+    {
+      assert ((int) regs->lr_reg[0] == FUNC_INT_ARG0);
+      assert ((int) regs->lr_reg[1] == FUNC_INT_ARG1);
+      assert ((int) regs->lr_reg[2] == FUNC_INT_ARG2);
+      assert ((int) regs->lr_reg[3] == FUNC_INT_ARG3);
+      assert ((int) regs->lr_reg[4] == FUNC_INT_ARG4);
+      assert ((int) regs->lr_reg[5] == FUNC_INT_ARG5);
+      assert ((int) regs->lr_reg[6] == FUNC_INT_ARG6);
+      assert ((int) regs->lr_reg[7] == FUNC_INT_ARG7);
+    }
+  else if (strcmp (symname, "tst_audit29_func_long") == 0)
+    {
+      assert ((long int) regs->lr_reg[0] == FUNC_LONG_ARG0);
+      assert ((long int) regs->lr_reg[1] == FUNC_LONG_ARG1);
+      assert ((long int) regs->lr_reg[2] == FUNC_LONG_ARG2);
+      assert ((long int) regs->lr_reg[3] == FUNC_LONG_ARG3);
+      assert ((long int) regs->lr_reg[4] == FUNC_LONG_ARG4);
+      assert ((long int) regs->lr_reg[5] == FUNC_LONG_ARG5);
+      assert ((long int) regs->lr_reg[6] == FUNC_LONG_ARG6);
+      assert ((long int) regs->lr_reg[7] == FUNC_LONG_ARG7);
+    }
+  else if (strcmp (symname, "tst_audit29_func_stack_long") == 0)
+    {
+      assert ((long int) regs->lr_reg[0] == FUNC_LONG_ARG0);
+      assert ((long int) regs->lr_reg[1] == FUNC_LONG_ARG1);
+      assert ((long int) regs->lr_reg[2] == FUNC_LONG_ARG2);
+      assert ((long int) regs->lr_reg[3] == FUNC_LONG_ARG3);
+      assert ((long int) regs->lr_reg[4] == FUNC_LONG_ARG4);
+      assert ((long int) regs->lr_reg[5] == FUNC_LONG_ARG5);
+      assert ((long int) regs->lr_reg[6] == FUNC_LONG_ARG6);
+      assert ((long int) regs->lr_reg[7] == FUNC_LONG_ARG7);
+      check_stack_long_args (regs);
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret2") == 0
+	   || strcmp (symname, "tst_audit29_func_ret2_modified") == 0)
+    {
+      /* No input parameters to check.  */
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret_large") == 0)
+    {
+      assert (regs->lr_reg[0] != 0);
+      assert ((char) regs->lr_reg[1] == FUNC_RET_LARGE_ARG0);
+      assert ((short) regs->lr_reg[2] == FUNC_RET_LARGE_ARG1);
+      assert ((long int) regs->lr_reg[3] == FUNC_RET_LARGE_ARG2);
+    }
+#ifndef __loongarch_soft_float
+  else if (strcmp (symname, "tst_audit29_func_float") == 0)
+    {
+      assert (fpreg_float (&regs->lr_vec[0]) == FUNC_FLOAT_ARG0);
+      assert (fpreg_float (&regs->lr_vec[1]) == FUNC_FLOAT_ARG1);
+      assert (fpreg_float (&regs->lr_vec[2]) == FUNC_FLOAT_ARG2);
+      assert (fpreg_float (&regs->lr_vec[3]) == FUNC_FLOAT_ARG3);
+      assert (fpreg_float (&regs->lr_vec[4]) == FUNC_FLOAT_ARG4);
+      assert (fpreg_float (&regs->lr_vec[5]) == FUNC_FLOAT_ARG5);
+      assert (fpreg_float (&regs->lr_vec[6]) == FUNC_FLOAT_ARG6);
+      assert (fpreg_float (&regs->lr_vec[7]) == FUNC_FLOAT_ARG7);
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret2_float") == 0
+	   || strcmp (symname, "tst_audit29_func_ret2_float_modified") == 0)
+    {
+      /* No input parameters to check.  */
+    }
+#if __loongarch_frlen == 64
+  else if (strcmp (symname, "tst_audit29_func_double") == 0)
+    {
+      assert (fpreg_double (&regs->lr_vec[0]) == FUNC_DOUBLE_ARG0);
+      assert (fpreg_double (&regs->lr_vec[1]) == FUNC_DOUBLE_ARG1);
+      assert (fpreg_double (&regs->lr_vec[2]) == FUNC_DOUBLE_ARG2);
+      assert (fpreg_double (&regs->lr_vec[3]) == FUNC_DOUBLE_ARG3);
+      assert (fpreg_double (&regs->lr_vec[4]) == FUNC_DOUBLE_ARG4);
+      assert (fpreg_double (&regs->lr_vec[5]) == FUNC_DOUBLE_ARG5);
+      assert (fpreg_double (&regs->lr_vec[6]) == FUNC_DOUBLE_ARG6);
+      assert (fpreg_double (&regs->lr_vec[7]) == FUNC_DOUBLE_ARG7);
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret2_double") == 0
+	   || strcmp (symname, "tst_audit29_func_ret2_double_modified") == 0)
+    {
+      /* No input parameters to check.  */
+    }
+#endif
+#endif
+  else
+    abort ();
+
+#ifndef __loongarch_soft_float
+  clobber_fp_regs ();
+#endif
+
+  /* A positive size asks the trampoline to reserve and copy a caller stack
+     frame.  This keeps stack arguments available to pltexit and also exercises
+     the frame-growth path.  */
+  *framesizep = 1024;
+
+  return sym->st_value;
+}
+
+unsigned int
+la_loongarch_gnu_pltexit (ElfW (Sym) *sym, unsigned int ndx,
+			  uintptr_t *refcook, uintptr_t *defcook,
+			  const La_loongarch_regs *inregs,
+			  La_loongarch_retval *outregs, const char *symname)
+{
+  printf ("pltexit: symname=%s, st_value=%#lx, ndx=%u\n",
+	  symname, (long int) sym->st_value, ndx);
+
+  if (strcmp (symname, "tst_audit29_func_int") == 0)
+    {
+      assert ((int) inregs->lr_reg[0] == FUNC_INT_ARG0);
+      assert ((int) inregs->lr_reg[1] == FUNC_INT_ARG1);
+      assert ((int) inregs->lr_reg[2] == FUNC_INT_ARG2);
+      assert ((int) inregs->lr_reg[3] == FUNC_INT_ARG3);
+      assert ((int) inregs->lr_reg[4] == FUNC_INT_ARG4);
+      assert ((int) inregs->lr_reg[5] == FUNC_INT_ARG5);
+      assert ((int) inregs->lr_reg[6] == FUNC_INT_ARG6);
+      assert ((int) inregs->lr_reg[7] == FUNC_INT_ARG7);
+
+      assert ((int) outregs->lrv_a0 == FUNC_INT_RET);
+    }
+  else if (strcmp (symname, "tst_audit29_func_long") == 0)
+    {
+      assert ((long int) inregs->lr_reg[0] == FUNC_LONG_ARG0);
+      assert ((long int) inregs->lr_reg[1] == FUNC_LONG_ARG1);
+      assert ((long int) inregs->lr_reg[2] == FUNC_LONG_ARG2);
+      assert ((long int) inregs->lr_reg[3] == FUNC_LONG_ARG3);
+      assert ((long int) inregs->lr_reg[4] == FUNC_LONG_ARG4);
+      assert ((long int) inregs->lr_reg[5] == FUNC_LONG_ARG5);
+      assert ((long int) inregs->lr_reg[6] == FUNC_LONG_ARG6);
+      assert ((long int) inregs->lr_reg[7] == FUNC_LONG_ARG7);
+
+      assert ((long int) outregs->lrv_a0 == FUNC_LONG_RET);
+    }
+  else if (strcmp (symname, "tst_audit29_func_stack_long") == 0)
+    {
+      assert ((long int) inregs->lr_reg[0] == FUNC_LONG_ARG0);
+      assert ((long int) inregs->lr_reg[1] == FUNC_LONG_ARG1);
+      assert ((long int) inregs->lr_reg[2] == FUNC_LONG_ARG2);
+      assert ((long int) inregs->lr_reg[3] == FUNC_LONG_ARG3);
+      assert ((long int) inregs->lr_reg[4] == FUNC_LONG_ARG4);
+      assert ((long int) inregs->lr_reg[5] == FUNC_LONG_ARG5);
+      assert ((long int) inregs->lr_reg[6] == FUNC_LONG_ARG6);
+      assert ((long int) inregs->lr_reg[7] == FUNC_LONG_ARG7);
+      check_stack_long_args (inregs);
+
+      assert ((long int) outregs->lrv_a0 == FUNC_STACK_LONG_RET);
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret2") == 0)
+    {
+      assert (outregs->lrv_a0 == FUNC_RET2_A0);
+      assert (outregs->lrv_a1 == FUNC_RET2_A1);
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret2_modified") == 0)
+    {
+      assert (outregs->lrv_a0 == FUNC_RET2_A0);
+      assert (outregs->lrv_a1 == FUNC_RET2_A1);
+
+      outregs->lrv_a0 = FUNC_RET2_A0_MODIFIED;
+      outregs->lrv_a1 = FUNC_RET2_A1_MODIFIED;
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret_large") == 0)
+    {
+      assert (inregs->lr_reg[0] != 0);
+      assert (outregs->lrv_a0 == inregs->lr_reg[0]);
+      assert ((char) inregs->lr_reg[1] == FUNC_RET_LARGE_ARG0);
+      assert ((short) inregs->lr_reg[2] == FUNC_RET_LARGE_ARG1);
+      assert ((long int) inregs->lr_reg[3] == FUNC_RET_LARGE_ARG2);
+    }
+#ifndef __loongarch_soft_float
+  else if (strcmp (symname, "tst_audit29_func_float") == 0)
+    {
+      assert (fpreg_float (&inregs->lr_vec[0]) == FUNC_FLOAT_ARG0);
+      assert (fpreg_float (&inregs->lr_vec[1]) == FUNC_FLOAT_ARG1);
+      assert (fpreg_float (&inregs->lr_vec[2]) == FUNC_FLOAT_ARG2);
+      assert (fpreg_float (&inregs->lr_vec[3]) == FUNC_FLOAT_ARG3);
+      assert (fpreg_float (&inregs->lr_vec[4]) == FUNC_FLOAT_ARG4);
+      assert (fpreg_float (&inregs->lr_vec[5]) == FUNC_FLOAT_ARG5);
+      assert (fpreg_float (&inregs->lr_vec[6]) == FUNC_FLOAT_ARG6);
+      assert (fpreg_float (&inregs->lr_vec[7]) == FUNC_FLOAT_ARG7);
+
+      assert (fpreg_float (&outregs->lrv_vec0) == FUNC_FLOAT_RET);
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret2_float") == 0)
+    {
+      assert (fpreg_float (&outregs->lrv_vec0) == FUNC_RET2_FP_A0);
+      assert (fpreg_float (&outregs->lrv_vec1) == FUNC_RET2_FP_A1);
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret2_float_modified") == 0)
+    {
+      assert (fpreg_float (&outregs->lrv_vec0) == FUNC_RET2_FP_A0);
+      assert (fpreg_float (&outregs->lrv_vec1) == FUNC_RET2_FP_A1);
+
+      set_fpreg_float (&outregs->lrv_vec0, FUNC_RET2_FP_A0_MODIFIED);
+      set_fpreg_float (&outregs->lrv_vec1, FUNC_RET2_FP_A1_MODIFIED);
+    }
+#if __loongarch_frlen == 64
+  else if (strcmp (symname, "tst_audit29_func_double") == 0)
+    {
+      assert (fpreg_double (&inregs->lr_vec[0]) == FUNC_DOUBLE_ARG0);
+      assert (fpreg_double (&inregs->lr_vec[1]) == FUNC_DOUBLE_ARG1);
+      assert (fpreg_double (&inregs->lr_vec[2]) == FUNC_DOUBLE_ARG2);
+      assert (fpreg_double (&inregs->lr_vec[3]) == FUNC_DOUBLE_ARG3);
+      assert (fpreg_double (&inregs->lr_vec[4]) == FUNC_DOUBLE_ARG4);
+      assert (fpreg_double (&inregs->lr_vec[5]) == FUNC_DOUBLE_ARG5);
+      assert (fpreg_double (&inregs->lr_vec[6]) == FUNC_DOUBLE_ARG6);
+      assert (fpreg_double (&inregs->lr_vec[7]) == FUNC_DOUBLE_ARG7);
+
+      assert (fpreg_double (&outregs->lrv_vec0) == FUNC_DOUBLE_RET);
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret2_double") == 0)
+    {
+      assert (fpreg_double (&outregs->lrv_vec0) == FUNC_RET2_FP_A0);
+      assert (fpreg_double (&outregs->lrv_vec1) == FUNC_RET2_FP_A1);
+    }
+  else if (strcmp (symname, "tst_audit29_func_ret2_double_modified") == 0)
+    {
+      assert (fpreg_double (&outregs->lrv_vec0) == FUNC_RET2_FP_A0);
+      assert (fpreg_double (&outregs->lrv_vec1) == FUNC_RET2_FP_A1);
+
+      set_fpreg_double (&outregs->lrv_vec0, FUNC_RET2_FP_A0_MODIFIED);
+      set_fpreg_double (&outregs->lrv_vec1, FUNC_RET2_FP_A1_MODIFIED);
+    }
+#endif
+#endif
+  else
+    abort ();
+
+#ifndef __loongarch_soft_float
+  clobber_fp_regs ();
+#endif
+
+  return 0;
+}
-- 
2.20.1



More information about the Libc-alpha mailing list