2022-02-07 17:23:17 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1 OR MIT */
|
|
|
|
|
/*
|
|
|
|
|
* ARM specific definitions for NOLIBC
|
|
|
|
|
* Copyright (C) 2017-2022 Willy Tarreau <w@1wt.eu>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef _NOLIBC_ARCH_ARM_H
|
|
|
|
|
#define _NOLIBC_ARCH_ARM_H
|
|
|
|
|
|
|
|
|
|
/* The struct returned by the stat() syscall, 32-bit only, the syscall returns
|
|
|
|
|
* exactly 56 bytes (stops before the unused array). In big endian, the format
|
|
|
|
|
* differs as devices are returned as short only.
|
|
|
|
|
*/
|
|
|
|
|
struct sys_stat_struct {
|
|
|
|
|
#if defined(__ARMEB__)
|
|
|
|
|
unsigned short st_dev;
|
|
|
|
|
unsigned short __pad1;
|
|
|
|
|
#else
|
|
|
|
|
unsigned long st_dev;
|
|
|
|
|
#endif
|
|
|
|
|
unsigned long st_ino;
|
|
|
|
|
unsigned short st_mode;
|
|
|
|
|
unsigned short st_nlink;
|
|
|
|
|
unsigned short st_uid;
|
|
|
|
|
unsigned short st_gid;
|
|
|
|
|
|
|
|
|
|
#if defined(__ARMEB__)
|
|
|
|
|
unsigned short st_rdev;
|
|
|
|
|
unsigned short __pad2;
|
|
|
|
|
#else
|
|
|
|
|
unsigned long st_rdev;
|
|
|
|
|
#endif
|
|
|
|
|
unsigned long st_size;
|
|
|
|
|
unsigned long st_blksize;
|
|
|
|
|
unsigned long st_blocks;
|
|
|
|
|
|
|
|
|
|
unsigned long st_atime;
|
|
|
|
|
unsigned long st_atime_nsec;
|
|
|
|
|
unsigned long st_mtime;
|
|
|
|
|
unsigned long st_mtime_nsec;
|
|
|
|
|
|
|
|
|
|
unsigned long st_ctime;
|
|
|
|
|
unsigned long st_ctime_nsec;
|
|
|
|
|
unsigned long __unused[2];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Syscalls for ARM in ARM or Thumb modes :
|
|
|
|
|
* - registers are 32-bit
|
|
|
|
|
* - stack is 8-byte aligned
|
|
|
|
|
* ( http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.faqs/ka4127.html)
|
|
|
|
|
* - syscall number is passed in r7
|
|
|
|
|
* - arguments are in r0, r1, r2, r3, r4, r5
|
|
|
|
|
* - the system call is performed by calling svc #0
|
|
|
|
|
* - syscall return comes in r0.
|
|
|
|
|
* - only lr is clobbered.
|
|
|
|
|
* - the arguments are cast to long and assigned into the target registers
|
|
|
|
|
* which are then simply passed as registers to the asm code, so that we
|
|
|
|
|
* don't have to experience issues with register constraints.
|
|
|
|
|
* - the syscall number is always specified last in order to allow to force
|
|
|
|
|
* some registers before (gcc refuses a %-register at the last position).
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
* - in thumb mode without -fomit-frame-pointer, r7 is also used to store the
|
|
|
|
|
* frame pointer, and we cannot directly assign it as a register variable,
|
|
|
|
|
* nor can we clobber it. Instead we assign the r6 register and swap it
|
|
|
|
|
* with r7 before calling svc, and r6 is marked as clobbered.
|
|
|
|
|
* We're just using any regular register which we assign to r7 after saving
|
|
|
|
|
* it.
|
2022-02-07 17:23:17 +01:00
|
|
|
*
|
|
|
|
|
* Also, ARM supports the old_select syscall if newselect is not available
|
|
|
|
|
*/
|
|
|
|
|
#define __ARCH_WANT_SYS_OLD_SELECT
|
|
|
|
|
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
#if (defined(__THUMBEB__) || defined(__THUMBEL__)) && \
|
|
|
|
|
!defined(NOLIBC_OMIT_FRAME_POINTER)
|
|
|
|
|
/* swap r6,r7 needed in Thumb mode since we can't use nor clobber r7 */
|
|
|
|
|
#define _NOLIBC_SYSCALL_REG "r6"
|
|
|
|
|
#define _NOLIBC_THUMB_SET_R7 "eor r7, r6\neor r6, r7\neor r7, r6\n"
|
|
|
|
|
#define _NOLIBC_THUMB_RESTORE_R7 "mov r7, r6\n"
|
|
|
|
|
|
|
|
|
|
#else /* we're in ARM mode */
|
|
|
|
|
/* in Arm mode we can directly use r7 */
|
|
|
|
|
#define _NOLIBC_SYSCALL_REG "r7"
|
|
|
|
|
#define _NOLIBC_THUMB_SET_R7 ""
|
|
|
|
|
#define _NOLIBC_THUMB_RESTORE_R7 ""
|
|
|
|
|
|
|
|
|
|
#endif /* end THUMB */
|
|
|
|
|
|
2022-02-07 17:23:17 +01:00
|
|
|
#define my_syscall0(num) \
|
|
|
|
|
({ \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
register long _num __asm__(_NOLIBC_SYSCALL_REG) = (num); \
|
2022-03-29 17:17:30 +07:00
|
|
|
register long _arg1 __asm__ ("r0"); \
|
2022-02-07 17:23:17 +01:00
|
|
|
\
|
2022-03-29 17:17:30 +07:00
|
|
|
__asm__ volatile ( \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_SET_R7 \
|
2022-02-07 17:23:17 +01:00
|
|
|
"svc #0\n" \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_RESTORE_R7 \
|
|
|
|
|
: "=r"(_arg1), "=r"(_num) \
|
|
|
|
|
: "r"(_arg1), \
|
|
|
|
|
"r"(_num) \
|
2022-02-07 17:23:17 +01:00
|
|
|
: "memory", "cc", "lr" \
|
|
|
|
|
); \
|
|
|
|
|
_arg1; \
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
#define my_syscall1(num, arg1) \
|
|
|
|
|
({ \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
register long _num __asm__(_NOLIBC_SYSCALL_REG) = (num); \
|
2022-03-29 17:17:30 +07:00
|
|
|
register long _arg1 __asm__ ("r0") = (long)(arg1); \
|
2022-02-07 17:23:17 +01:00
|
|
|
\
|
2022-03-29 17:17:30 +07:00
|
|
|
__asm__ volatile ( \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_SET_R7 \
|
2022-02-07 17:23:17 +01:00
|
|
|
"svc #0\n" \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_RESTORE_R7 \
|
|
|
|
|
: "=r"(_arg1), "=r" (_num) \
|
2022-02-07 17:23:17 +01:00
|
|
|
: "r"(_arg1), \
|
|
|
|
|
"r"(_num) \
|
|
|
|
|
: "memory", "cc", "lr" \
|
|
|
|
|
); \
|
|
|
|
|
_arg1; \
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
#define my_syscall2(num, arg1, arg2) \
|
|
|
|
|
({ \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
register long _num __asm__(_NOLIBC_SYSCALL_REG) = (num); \
|
2022-03-29 17:17:30 +07:00
|
|
|
register long _arg1 __asm__ ("r0") = (long)(arg1); \
|
|
|
|
|
register long _arg2 __asm__ ("r1") = (long)(arg2); \
|
2022-02-07 17:23:17 +01:00
|
|
|
\
|
2022-03-29 17:17:30 +07:00
|
|
|
__asm__ volatile ( \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_SET_R7 \
|
2022-02-07 17:23:17 +01:00
|
|
|
"svc #0\n" \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_RESTORE_R7 \
|
|
|
|
|
: "=r"(_arg1), "=r" (_num) \
|
2022-02-07 17:23:17 +01:00
|
|
|
: "r"(_arg1), "r"(_arg2), \
|
|
|
|
|
"r"(_num) \
|
|
|
|
|
: "memory", "cc", "lr" \
|
|
|
|
|
); \
|
|
|
|
|
_arg1; \
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
#define my_syscall3(num, arg1, arg2, arg3) \
|
|
|
|
|
({ \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
register long _num __asm__(_NOLIBC_SYSCALL_REG) = (num); \
|
2022-03-29 17:17:30 +07:00
|
|
|
register long _arg1 __asm__ ("r0") = (long)(arg1); \
|
|
|
|
|
register long _arg2 __asm__ ("r1") = (long)(arg2); \
|
|
|
|
|
register long _arg3 __asm__ ("r2") = (long)(arg3); \
|
2022-02-07 17:23:17 +01:00
|
|
|
\
|
2022-03-29 17:17:30 +07:00
|
|
|
__asm__ volatile ( \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_SET_R7 \
|
2022-02-07 17:23:17 +01:00
|
|
|
"svc #0\n" \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_RESTORE_R7 \
|
|
|
|
|
: "=r"(_arg1), "=r" (_num) \
|
2022-02-07 17:23:17 +01:00
|
|
|
: "r"(_arg1), "r"(_arg2), "r"(_arg3), \
|
|
|
|
|
"r"(_num) \
|
|
|
|
|
: "memory", "cc", "lr" \
|
|
|
|
|
); \
|
|
|
|
|
_arg1; \
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
#define my_syscall4(num, arg1, arg2, arg3, arg4) \
|
|
|
|
|
({ \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
register long _num __asm__(_NOLIBC_SYSCALL_REG) = (num); \
|
2022-03-29 17:17:30 +07:00
|
|
|
register long _arg1 __asm__ ("r0") = (long)(arg1); \
|
|
|
|
|
register long _arg2 __asm__ ("r1") = (long)(arg2); \
|
|
|
|
|
register long _arg3 __asm__ ("r2") = (long)(arg3); \
|
|
|
|
|
register long _arg4 __asm__ ("r3") = (long)(arg4); \
|
2022-02-07 17:23:17 +01:00
|
|
|
\
|
2022-03-29 17:17:30 +07:00
|
|
|
__asm__ volatile ( \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_SET_R7 \
|
2022-02-07 17:23:17 +01:00
|
|
|
"svc #0\n" \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_RESTORE_R7 \
|
|
|
|
|
: "=r"(_arg1), "=r" (_num) \
|
2022-02-07 17:23:17 +01:00
|
|
|
: "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), \
|
|
|
|
|
"r"(_num) \
|
|
|
|
|
: "memory", "cc", "lr" \
|
|
|
|
|
); \
|
|
|
|
|
_arg1; \
|
|
|
|
|
})
|
|
|
|
|
|
|
|
|
|
#define my_syscall5(num, arg1, arg2, arg3, arg4, arg5) \
|
|
|
|
|
({ \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
register long _num __asm__(_NOLIBC_SYSCALL_REG) = (num); \
|
2022-03-29 17:17:30 +07:00
|
|
|
register long _arg1 __asm__ ("r0") = (long)(arg1); \
|
|
|
|
|
register long _arg2 __asm__ ("r1") = (long)(arg2); \
|
|
|
|
|
register long _arg3 __asm__ ("r2") = (long)(arg3); \
|
|
|
|
|
register long _arg4 __asm__ ("r3") = (long)(arg4); \
|
|
|
|
|
register long _arg5 __asm__ ("r4") = (long)(arg5); \
|
2022-02-07 17:23:17 +01:00
|
|
|
\
|
2022-03-29 17:17:30 +07:00
|
|
|
__asm__ volatile ( \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_SET_R7 \
|
2022-02-07 17:23:17 +01:00
|
|
|
"svc #0\n" \
|
tools/nolibc: support thumb mode with frame pointers on ARM
In Thumb mode, register r7 is normally used to store the frame pointer.
By default when optimizing at -Os there's no frame pointer so this works
fine. But if no optimization is set, then build errors occur, indicating
that r7 cannot not be used. It's difficult to cheat because it's the
compiler that is complaining, not the assembler, so it's not even possible
to report that the register was clobbered. The solution consists in saving
and restoring r7 around the syscall, but this slightly inflates the code.
The syscall number is passed via r6 which is never used by syscalls.
The current patch adds a few macroes which do that only in Thumb mode,
and which continue to directly assign the syscall number to register r7
in ARM mode. Now this always builds and works for all modes (tested on
Arm, Thumbv1, Thumbv2 modes, at -Os, -O0, -O0 -fomit-frame-pointer).
The code is very slightly inflated in thumb-mode without frame-pointers
compared to previously (e.g. 7928 vs 7864 bytes for nolibc-test) but at
least it's always operational. And it's possible to disable this mechanism
by setting NOLIBC_OMIT_FRAME_POINTER.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:15 +01:00
|
|
|
_NOLIBC_THUMB_RESTORE_R7 \
|
|
|
|
|
: "=r"(_arg1), "=r" (_num) \
|
2022-02-07 17:23:17 +01:00
|
|
|
: "r"(_arg1), "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5), \
|
|
|
|
|
"r"(_num) \
|
|
|
|
|
: "memory", "cc", "lr" \
|
|
|
|
|
); \
|
|
|
|
|
_arg1; \
|
|
|
|
|
})
|
|
|
|
|
|
2023-01-10 08:24:21 +01:00
|
|
|
char **environ __attribute__((weak));
|
2023-01-10 08:24:28 +01:00
|
|
|
const unsigned long *_auxv __attribute__((weak));
|
2023-01-10 08:24:21 +01:00
|
|
|
|
2022-02-07 17:23:17 +01:00
|
|
|
/* startup code */
|
tools/nolibc: make compiler and assembler agree on the section around _start
The out-of-block asm() statement carrying _start does not allow the
compiler to know what section the assembly code is being emitted to,
and there's no easy way to push/pop the current section and restore
it. It sometimes causes issues depending on the include files ordering
and compiler optimizations. For example if a variable is declared
immediately before the asm() block and another one after, the compiler
assumes that the current section is still .bss and doesn't re-emit it,
making the second variable appear inside the .text section instead.
Forcing .bss at the end of the _start block doesn't work either because
at certain optimizations the compiler may reorder blocks and will make
some real code appear just after this block.
A significant number of solutions were attempted, but many of them were
still sensitive to section reordering. In the end, the best way to make
sure the compiler and assembler agree on the current section is to place
this code inside a function. Here the function is directly called _start
and configured not to emit a frame-pointer, hence to have no prologue.
If some future architectures would still emit some prologue, another
working approach consists in naming the function differently and placing
the _start label inside the asm statement. But the current solution is
simpler.
It was tested with nolibc-test at -O,-O0,-O2,-O3,-Os for arm,arm64,i386,
mips,riscv,s390 and x86_64.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:13 +01:00
|
|
|
void __attribute__((weak,noreturn,optimize("omit-frame-pointer"))) _start(void)
|
|
|
|
|
{
|
|
|
|
|
__asm__ volatile (
|
|
|
|
|
"pop {%r0}\n" // argc was in the stack
|
|
|
|
|
"mov %r1, %sp\n" // argv = sp
|
2023-01-10 08:24:14 +01:00
|
|
|
|
|
|
|
|
"add %r2, %r0, $1\n" // envp = (argc + 1) ...
|
|
|
|
|
"lsl %r2, %r2, $2\n" // * 4 ...
|
|
|
|
|
"add %r2, %r2, %r1\n" // + argv
|
2023-01-10 08:24:21 +01:00
|
|
|
"ldr %r3, 1f\n" // r3 = &environ (see below)
|
|
|
|
|
"str %r2, [r3]\n" // store envp into environ
|
2023-01-10 08:24:14 +01:00
|
|
|
|
2023-01-10 08:24:28 +01:00
|
|
|
"mov r4, r2\n" // search for auxv (follows NULL after last env)
|
|
|
|
|
"0:\n"
|
|
|
|
|
"mov r5, r4\n" // r5 = r4
|
|
|
|
|
"add r4, r4, #4\n" // r4 += 4
|
|
|
|
|
"ldr r5,[r5]\n" // r5 = *r5 = *(r4-4)
|
|
|
|
|
"cmp r5, #0\n" // and stop at NULL after last env
|
|
|
|
|
"bne 0b\n"
|
|
|
|
|
"ldr %r3, 2f\n" // r3 = &_auxv (low bits)
|
|
|
|
|
"str r4, [r3]\n" // store r4 into _auxv
|
|
|
|
|
|
2023-01-10 08:24:14 +01:00
|
|
|
"mov %r3, $8\n" // AAPCS : sp must be 8-byte aligned in the
|
|
|
|
|
"neg %r3, %r3\n" // callee, and bl doesn't push (lr=pc)
|
|
|
|
|
"and %r3, %r3, %r1\n" // so we do sp = r1(=sp) & r3(=-8);
|
|
|
|
|
"mov %sp, %r3\n" //
|
|
|
|
|
|
tools/nolibc: make compiler and assembler agree on the section around _start
The out-of-block asm() statement carrying _start does not allow the
compiler to know what section the assembly code is being emitted to,
and there's no easy way to push/pop the current section and restore
it. It sometimes causes issues depending on the include files ordering
and compiler optimizations. For example if a variable is declared
immediately before the asm() block and another one after, the compiler
assumes that the current section is still .bss and doesn't re-emit it,
making the second variable appear inside the .text section instead.
Forcing .bss at the end of the _start block doesn't work either because
at certain optimizations the compiler may reorder blocks and will make
some real code appear just after this block.
A significant number of solutions were attempted, but many of them were
still sensitive to section reordering. In the end, the best way to make
sure the compiler and assembler agree on the current section is to place
this code inside a function. Here the function is directly called _start
and configured not to emit a frame-pointer, hence to have no prologue.
If some future architectures would still emit some prologue, another
working approach consists in naming the function differently and placing
the _start label inside the asm statement. But the current solution is
simpler.
It was tested with nolibc-test at -O,-O0,-O2,-O3,-Os for arm,arm64,i386,
mips,riscv,s390 and x86_64.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:13 +01:00
|
|
|
"bl main\n" // main() returns the status code, we'll exit with it.
|
|
|
|
|
"movs r7, $1\n" // NR_exit == 1
|
|
|
|
|
"svc $0x00\n"
|
2023-01-10 08:24:21 +01:00
|
|
|
".align 2\n" // below are the pointers to a few variables
|
|
|
|
|
"1:\n"
|
|
|
|
|
".word environ\n"
|
2023-01-10 08:24:28 +01:00
|
|
|
"2:\n"
|
|
|
|
|
".word _auxv\n"
|
2023-01-10 08:24:21 +01:00
|
|
|
);
|
tools/nolibc: make compiler and assembler agree on the section around _start
The out-of-block asm() statement carrying _start does not allow the
compiler to know what section the assembly code is being emitted to,
and there's no easy way to push/pop the current section and restore
it. It sometimes causes issues depending on the include files ordering
and compiler optimizations. For example if a variable is declared
immediately before the asm() block and another one after, the compiler
assumes that the current section is still .bss and doesn't re-emit it,
making the second variable appear inside the .text section instead.
Forcing .bss at the end of the _start block doesn't work either because
at certain optimizations the compiler may reorder blocks and will make
some real code appear just after this block.
A significant number of solutions were attempted, but many of them were
still sensitive to section reordering. In the end, the best way to make
sure the compiler and assembler agree on the current section is to place
this code inside a function. Here the function is directly called _start
and configured not to emit a frame-pointer, hence to have no prologue.
If some future architectures would still emit some prologue, another
working approach consists in naming the function differently and placing
the _start label inside the asm statement. But the current solution is
simpler.
It was tested with nolibc-test at -O,-O0,-O2,-O3,-Os for arm,arm64,i386,
mips,riscv,s390 and x86_64.
Signed-off-by: Willy Tarreau <w@1wt.eu>
Signed-off-by: Paul E. McKenney <paulmck@kernel.org>
2023-01-10 08:24:13 +01:00
|
|
|
__builtin_unreachable();
|
|
|
|
|
}
|
2022-02-07 17:23:17 +01:00
|
|
|
|
|
|
|
|
#endif // _NOLIBC_ARCH_ARM_H
|