tools/include/nolibc/arch-sparc.h

/* SPDX-License-Identifier: LGPL-2.1 OR MIT */
/*
 * SPARC (32bit and 64bit) specific definitions for NOLIBC
 * Copyright (C) 2025 Thomas Weißschuh <linux@weissschuh.net>
 */

#ifndef _NOLIBC_ARCH_SPARC_H
#define _NOLIBC_ARCH_SPARC_H

#include <linux/unistd.h>

#include "compiler.h"
#include "crt.h"

/*
 * Syscalls for SPARC:
 *   - registers are native word size
 *   - syscall number is passed in g1
 *   - arguments are in o0-o5
 *   - the system call is performed by calling a trap instruction
 *   - syscall return value is in o0
 *   - syscall error flag is in the carry bit of the processor status register
 */

#ifdef __arch64__

#define _NOLIBC_SYSCALL "t	0x6d\n"                                       \
			"bcs,a	%%xcc, 1f\n"                                  \
			"sub	%%g0, %%o0, %%o0\n"                           \
			"1:\n"

#else

#define _NOLIBC_SYSCALL "t	0x10\n"                                       \
			"bcs,a	1f\n"                                         \
			"sub	%%g0, %%o0, %%o0\n"                           \
			"1:\n"

#endif /* __arch64__ */

#define my_syscall0(num)                                                      \
({                                                                            \
	register long _num  __asm__ ("g1") = (num);                           \
	register long _arg1 __asm__ ("o0");                                   \
									      \
	__asm__ volatile (                                                    \
		_NOLIBC_SYSCALL                                               \
		: "+r"(_arg1)                                                 \
		: "r"(_num)                                                   \
		: "memory", "cc"                                              \
	);                                                                    \
	_arg1;                                                                \
})

#define my_syscall1(num, arg1)                                                \
({                                                                            \
	register long _num  __asm__ ("g1") = (num);                           \
	register long _arg1 __asm__ ("o0") = (long)(arg1);                    \
									      \
	__asm__ volatile (                                                    \
		_NOLIBC_SYSCALL                                               \
		: "+r"(_arg1)                                                 \
		: "r"(_num)                                                   \
		: "memory", "cc"                                              \
	);                                                                    \
	_arg1;                                                                \
})

#define my_syscall2(num, arg1, arg2)                                          \
({                                                                            \
	register long _num  __asm__ ("g1") = (num);                           \
	register long _arg1 __asm__ ("o0") = (long)(arg1);                    \
	register long _arg2 __asm__ ("o1") = (long)(arg2);                    \
									      \
	__asm__ volatile (                                                    \
		_NOLIBC_SYSCALL                                               \
		: "+r"(_arg1)                                                 \
		: "r"(_arg2), "r"(_num)                                       \
		: "memory", "cc"                                              \
	);                                                                    \
	_arg1;                                                                \
})

#define my_syscall3(num, arg1, arg2, arg3)                                    \
({                                                                            \
	register long _num  __asm__ ("g1") = (num);                           \
	register long _arg1 __asm__ ("o0") = (long)(arg1);                    \
	register long _arg2 __asm__ ("o1") = (long)(arg2);                    \
	register long _arg3 __asm__ ("o2") = (long)(arg3);                    \
									      \
	__asm__ volatile (                                                    \
		_NOLIBC_SYSCALL                                               \
		: "+r"(_arg1)                                                 \
		: "r"(_arg2), "r"(_arg3), "r"(_num)                           \
		: "memory", "cc"                                              \
	);                                                                    \
	_arg1;                                                                \
})

#define my_syscall4(num, arg1, arg2, arg3, arg4)                              \
({                                                                            \
	register long _num  __asm__ ("g1") = (num);                           \
	register long _arg1 __asm__ ("o0") = (long)(arg1);                    \
	register long _arg2 __asm__ ("o1") = (long)(arg2);                    \
	register long _arg3 __asm__ ("o2") = (long)(arg3);                    \
	register long _arg4 __asm__ ("o3") = (long)(arg4);                    \
									      \
	__asm__ volatile (                                                    \
		_NOLIBC_SYSCALL                                               \
		: "+r"(_arg1)                                                 \
		: "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_num)               \
		: "memory", "cc"                                              \
	);                                                                    \
	_arg1;                                                                \
})

#define my_syscall5(num, arg1, arg2, arg3, arg4, arg5)                        \
({                                                                            \
	register long _num  __asm__ ("g1") = (num);                           \
	register long _arg1 __asm__ ("o0") = (long)(arg1);                    \
	register long _arg2 __asm__ ("o1") = (long)(arg2);                    \
	register long _arg3 __asm__ ("o2") = (long)(arg3);                    \
	register long _arg4 __asm__ ("o3") = (long)(arg4);                    \
	register long _arg5 __asm__ ("o4") = (long)(arg5);                    \
									      \
	__asm__ volatile (                                                    \
		_NOLIBC_SYSCALL                                               \
		: "+r"(_arg1)                                                 \
		: "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5), "r"(_num)   \
		: "memory", "cc"                                              \
	);                                                                    \
	_arg1;                                                                \
})

#define my_syscall6(num, arg1, arg2, arg3, arg4, arg5, arg6)                  \
({                                                                            \
	register long _num  __asm__ ("g1") = (num);                           \
	register long _arg1 __asm__ ("o0") = (long)(arg1);                    \
	register long _arg2 __asm__ ("o1") = (long)(arg2);                    \
	register long _arg3 __asm__ ("o2") = (long)(arg3);                    \
	register long _arg4 __asm__ ("o3") = (long)(arg4);                    \
	register long _arg5 __asm__ ("o4") = (long)(arg5);                    \
	register long _arg6 __asm__ ("o5") = (long)(arg6);                    \
									      \
	__asm__ volatile (                                                    \
		_NOLIBC_SYSCALL                                               \
		: "+r"(_arg1)                                                 \
		: "r"(_arg2), "r"(_arg3), "r"(_arg4), "r"(_arg5), "r"(_arg6), \
		  "r"(_num)                                                   \
		: "memory", "cc"                                              \
	);                                                                    \
	_arg1;                                                                \
})

/* startup code */
void __attribute__((weak, noreturn)) __nolibc_entrypoint __no_stack_protector _start(void)
{
	__asm__ volatile (
		/*
		 * Save argc pointer to o0, as arg1 of _start_c.
		 * Account for the window save area, which is 16 registers wide.
		 */
#ifdef __arch64__
		"add %sp, 128 + 2047, %o0\n" /* on sparc64 / v9 the stack is offset by 2047 */
#else
		"add %sp, 64, %o0\n"
#endif
		"b,a _start_c\n"     /* transfer to c runtime */
	);
	__nolibc_entrypoint_epilogue();
}

static pid_t getpid(void);

static __attribute__((unused))
pid_t sys_fork(void)
{
	pid_t parent, ret;

	parent = getpid();
	ret = my_syscall0(__NR_fork);

	/* The syscall returns the parent pid in the child instead of 0 */
	if (ret == parent)
		return 0;
	else
		return ret;
}
#define sys_fork sys_fork

static __attribute__((unused))
pid_t sys_vfork(void)
{
	pid_t parent, ret;

	parent = getpid();
	ret = my_syscall0(__NR_vfork);

	/* The syscall returns the parent pid in the child instead of 0 */
	if (ret == parent)
		return 0;
	else
		return ret;
}
#define sys_vfork sys_vfork

#endif /* _NOLIBC_ARCH_SPARC_H */