[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 (®s->lr_vec[0]) == FUNC_FLOAT_ARG0);
+ assert (fpreg_float (®s->lr_vec[1]) == FUNC_FLOAT_ARG1);
+ assert (fpreg_float (®s->lr_vec[2]) == FUNC_FLOAT_ARG2);
+ assert (fpreg_float (®s->lr_vec[3]) == FUNC_FLOAT_ARG3);
+ assert (fpreg_float (®s->lr_vec[4]) == FUNC_FLOAT_ARG4);
+ assert (fpreg_float (®s->lr_vec[5]) == FUNC_FLOAT_ARG5);
+ assert (fpreg_float (®s->lr_vec[6]) == FUNC_FLOAT_ARG6);
+ assert (fpreg_float (®s->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 (®s->lr_vec[0]) == FUNC_DOUBLE_ARG0);
+ assert (fpreg_double (®s->lr_vec[1]) == FUNC_DOUBLE_ARG1);
+ assert (fpreg_double (®s->lr_vec[2]) == FUNC_DOUBLE_ARG2);
+ assert (fpreg_double (®s->lr_vec[3]) == FUNC_DOUBLE_ARG3);
+ assert (fpreg_double (®s->lr_vec[4]) == FUNC_DOUBLE_ARG4);
+ assert (fpreg_double (®s->lr_vec[5]) == FUNC_DOUBLE_ARG5);
+ assert (fpreg_double (®s->lr_vec[6]) == FUNC_DOUBLE_ARG6);
+ assert (fpreg_double (®s->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