rstd_platform.h

//////////////////////////////////////
// NOTE: Wrappable Platform Syscalls
#ifndef RSTD_PLATFORM_H
#define RSTD_PLATFORM_H

#define MaxPathLength      (1024UL)

#define InvalidHandleValue (-1ULL)
#define InvalidHandle      {InvalidHandleValue}

typedef struct { u64 value[1]; } FileHandle;

typedef enum {
	FileOpenFlag_Write  = 1 << 0,
	FileOpenFlag_Read   = 1 << 1,
	FileOpenFlag_Reset  = 1 << 2,
	FileOpenFlag_Create = 1 << 3,
} FileOpenFlags;

#if OS_LINUX

#define ValidLinuxResult(r)   ((r) <= -4096UL)
#define InvalidLinuxResult(r) ((r)  > -4096UL)

#define LinuxConstant_O_RDONLY (0x0000)
#define LinuxConstant_O_WRONLY (0x0001)
#define LinuxConstant_O_RDWR   (0x0002)
#define LinuxConstant_O_CREAT  (0x0040)
#define LinuxConstant_O_TRUNC  (0x0200)
#define LinuxConstant_O_APPEND (0x0400)

#define LinuxConstant_EINTR    (-4UL)

#define LinuxConstant_AT_FDCWD (-100)

#define LINUX_EINTR_LOOP(result, expr) do { \
	(result) = (expr); \
} while (InvalidLinuxResult(result) && (result) == LinuxConstant_EINTR)

#if ARCH_X64

typedef enum {
	LinuxSyscall_read               =   0,
	LinuxSyscall_write              =   1,
	LinuxSyscall_close              =   3,
	LinuxSyscall_exit               =  60,
	LinuxSyscall_openat             = 257,
} LinuxSyscall;

function force_inline u64
syscall1(LinuxSyscall n, s64 a1)
{
	u64 result;
	asm volatile ("syscall"
		: "=a"(result)
		: "a"(n), "D"(a1)
		: "rcx", "r11", "memory"
	);
	return result;
}

function force_inline u64
syscall2(LinuxSyscall n, s64 a1, s64 a2)
{
	s64 result;
	asm volatile ("syscall"
		: "=a"(result)
		: "a"(n), "D"(a1), "S"(a2)
		: "rcx", "r11", "memory"
	);
	return result;
}

function force_inline u64
syscall3(LinuxSyscall n, s64 a1, s64 a2, s64 a3)
{
	u64 result;
	asm volatile ("syscall"
		: "=a"(result)
		: "a"(n), "D"(a1), "S"(a2), "d"(a3)
		: "rcx", "r11", "memory"
	);
	return result;
}

function force_inline u64
syscall4(LinuxSyscall n, s64 a1, s64 a2, s64 a3, s64 a4)
{
	u64 result;
	register s64 r10 asm("r10") = a4;
	asm volatile ("syscall"
		: "=a"(result)
		: "a"(n), "D"(a1), "S"(a2), "d"(a3), "r"(r10)
		: "rcx", "r11", "memory"
	);
	return result;
}

function force_inline u64
syscall5(LinuxSyscall n, s64 a1, s64 a2, s64 a3, s64 a4, s64 a5)
{
	u64 result;
	register s64 r10 asm("r10") = a4;
	register s64 r8  asm("r8")  = a5;
	asm volatile ("syscall"
		: "=a"(result)
		: "a"(n), "D"(a1), "S"(a2), "d"(a3), "r"(r10), "r"(r8)
		: "rcx", "r11", "memory"
	);
	return result;
}

function force_inline u64
syscall6(LinuxSyscall n, s64 a1, s64 a2, s64 a3, s64 a4, s64 a5, s64 a6)
{
	s64 result;
	register s64 r10 asm("r10") = a4;
	register s64 r8  asm("r8")  = a5;
	register s64 r9  asm("r9")  = a6;
	asm volatile ("syscall"
		: "=a"(result)
		: "a"(n), "D"(a1), "S"(a2), "d"(a3), "r"(r10), "r"(r8), "r"(r9)
		: "rcx", "r11", "memory"
	);
	return result;
}

#elif ARCH_ARM64

typedef enum {
	LinuxSyscall_openat             =  56,
	LinuxSyscall_close              =  57,
	LinuxSyscall_read               =  63,
	LinuxSyscall_write              =  64,
	LinuxSyscall_exit               =  93,
} LinuxSyscall;

function force_inline s64
syscall1(s64 n, s64 a1)
{
	register s64 x8 asm("x8") = n;
	register s64 x0 asm("x0") = a1;
	asm volatile ("svc 0"
		: "=r"(x0)
		: "0"(x0), "r"(x8)
		: "memory", "cc"
	);
	return x0;
}

function force_inline s64
syscall2(s64 n, s64 a1, s64 a2)
{
	register s64 x8 asm("x8") = n;
	register s64 x0 asm("x0") = a1;
	register s64 x1 asm("x1") = a2;
	asm volatile ("svc 0"
		: "=r"(x0)
		: "0"(x0), "r"(x8), "r"(x1)
		: "memory", "cc"
	);
	return x0;
}

function force_inline s64
syscall3(s64 n, s64 a1, s64 a2, s64 a3)
{
	register s64 x8 asm("x8") = n;
	register s64 x0 asm("x0") = a1;
	register s64 x1 asm("x1") = a2;
	register s64 x2 asm("x2") = a3;
	asm volatile ("svc 0"
		: "=r"(x0)
		: "0"(x0), "r"(x8), "r"(x1), "r"(x2)
		: "memory", "cc"
	);
	return x0;
}

function force_inline s64
syscall4(s64 n, s64 a1, s64 a2, s64 a3, s64 a4)
{
	register s64 x8 asm("x8") = n;
	register s64 x0 asm("x0") = a1;
	register s64 x1 asm("x1") = a2;
	register s64 x2 asm("x2") = a3;
	register s64 x3 asm("x3") = a4;
	asm volatile ("svc 0"
		: "=r"(x0)
		: "0"(x0), "r"(x8), "r"(x1), "r"(x2), "r"(x3)
		: "memory", "cc"
	);
	return x0;
}

function force_inline s64
syscall5(s64 n, s64 a1, s64 a2, s64 a3, s64 a4, s64 a5)
{
	register s64 x8 asm("x8") = n;
	register s64 x0 asm("x0") = a1;
	register s64 x1 asm("x1") = a2;
	register s64 x2 asm("x2") = a3;
	register s64 x3 asm("x3") = a4;
	register s64 x4 asm("x4") = a5;
	asm volatile ("svc 0"
		: "=r"(x0)
		: "0"(x0), "r"(x8), "r"(x1), "r"(x2), "r"(x3), "r"(x4),
		: "memory", "cc"
	);
	return x0;
}

function force_inline s64
syscall6(s64 n, s64 a1, s64 a2, s64 a3, s64 a4, s64 a5, s64 a6)
{
	register s64 x8 asm("x8") = n;
	register s64 x0 asm("x0") = a1;
	register s64 x1 asm("x1") = a2;
	register s64 x2 asm("x2") = a3;
	register s64 x3 asm("x3") = a4;
	register s64 x4 asm("x4") = a5;
	register s64 x5 asm("x5") = a6;
	asm volatile ("svc 0"
		: "=r"(x0)
		: "0"(x0), "r"(x8), "r"(x1), "r"(x2), "r"(x3), "r"(x4), "r"(x5)
		: "memory", "cc"
	);
	return x0;
}

#else
#error Architecture not supported on Linux
#endif

function FileHandle
sys_stdout_handle(void)
{
	FileHandle result = {1};
	return result;
}

function void
sys_close(FileHandle h)
{
	u64 sysret;
	LINUX_EINTR_LOOP(sysret, syscall1(LinuxSyscall_close, (s64)h.value[0]));
}

function FileHandle
sys_open_file_at(str8 path, FileHandle directory, FileOpenFlags flags)
{
	char cpath[MaxPathLength];

	u64  path_length = Min(path.length, countof(cpath) - 1);
	memory_copy(cpath, path.data, path_length);
	cpath[path_length] = 0;

	s32 linux_flags = 0;
	if (flags & FileOpenFlag_Write) {
		linux_flags |= (flags & FileOpenFlag_Read) ? LinuxConstant_O_RDWR : LinuxConstant_O_WRONLY;
	} else if (flags & FileOpenFlag_Read) {
		linux_flags |= LinuxConstant_O_RDONLY;
	}

	if (flags & FileOpenFlag_Create) linux_flags |= LinuxConstant_O_CREAT;
	if (flags & FileOpenFlag_Reset)  linux_flags |= LinuxConstant_O_TRUNC;
	else                             linux_flags |= LinuxConstant_O_APPEND;

	FileHandle result = InvalidHandle;
	s64 directory_descriptor = directory.value[0];
	if (directory_descriptor == -1) directory_descriptor = LinuxConstant_AT_FDCWD;

	u64 sysret;
	LINUX_EINTR_LOOP(sysret, syscall4(LinuxSyscall_openat, directory_descriptor, (s64)cpath, linux_flags, 0644));
	if ValidLinuxResult(sysret)
		result.value[0] = sysret;

	return result;
}

function s64
sys_read(FileHandle h, void *output_buffer, s64 read_length)
{
	u64 result;
	LINUX_EINTR_LOOP(result, syscall3(LinuxSyscall_read, (s64)h.value[0], (s64)output_buffer, read_length));
	return result;
}

function s64
sys_write(FileHandle h, void *data, s64 write_length)
{
	u64 result;
	LINUX_EINTR_LOOP(result, syscall3(LinuxSyscall_write, (s64)h.value[0], (s64)data, write_length));
	return (s64)result;
}

function no_return void
sys_exit(s64 exit_status)
{
	syscall1(LinuxSyscall_exit, exit_status);
	unreachable();
}

#endif /* OS_LINUX */

#endif /* RSTD_PLATFORM_H */