#include <fcntl.h>
#include <stdint.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/mman.h>
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
typedef float f32;
typedef double f64;
typedef u32 Hash;
#define fn static
#define global static
#define assert(x) if (__builtin_expect(!(x), 0)) { trap(); }
#define forceinline __attribute__((always_inline))
#define expect(x, b) __builtin_expect(x, b)
#define trap() __builtin_trap()
#define array_length(arr) sizeof(arr) / sizeof((arr)[0])
#define page_size (0x1000)
#define unused(x) (void)(x)
#define KB(n) ((n) * 1024)
#define MB(n) ((n) * 1024 * 1024)
#define GB(n) ((u64)(n) * 1024 * 1024 * 1024)
#define TB(n) ((u64)(n) * 1024 * 1024 * 1024 * 1024)
template<typename T>
struct DynamicList
{
T* pointer;
u64 count;
DynamicList* next;
};
template<typename T, u64 count>
struct StaticList
{
u64 length;
StaticList* next;
T array[count];
};
extern "C" void* memcpy(void* __restrict dst, void* __restrict src, u64 size)
{
auto* destination = (u8*)dst;
auto* source = (u8*)src;
for (u64 i = 0; i < size; i += 1)
{
destination[i] = source[i];
}
return dst;
}
extern "C" void* memset(void* dst, u8 n, u64 size)
{
auto* destination = (u8*)dst;
for (u64 i = 0; i < size; i += 1)
{
destination[i] = n;
}
return dst;
}
extern "C" int memcmp(const void* left, const void* right, u64 n)
{
const u8 *l=(const u8*)left, *r=(const u8*)right;
for (; n && *l == *r; n--, l++, r++);
return n ? *l - *r : 0;
}
template<typename T>
forceinline fn u8 mem_equal_range(T* a, T* b, u64 count)
{
return memcmp(a, b, count * sizeof(T)) == 0;
}
template <typename T>
forceinline fn T min(T a, T b)
{
return a < b ? a : b;
}
template <typename T>
forceinline fn T max(T a, T b)
{
return a > b ? a : b;
}
template<typename T>
struct Slice
{
T* pointer;
u64 length;
T& operator[](u64 index)
{
assert(index < length);
return pointer[index];
}
Slice slice(u64 start, u64 end)
{
return {
.pointer = pointer + start,
.length = end - start,
};
}
forceinline u8 equal(Slice other)
{
if (length == other.length)
{
return mem_equal_range(pointer, other.pointer, length);
}
else
{
return 0;
}
}
forceinline T* begin()
{
return pointer;
}
forceinline T* end()
{
return pointer + length;
}
};
using String = Slice<u8>;
#define strlit(s) String{ .pointer = (u8*)s, .length = sizeof(s) - 1, }
#define ch_to_str(ch) String{ .pointer = &ch, .length = 1 }
global auto constexpr fnv_offset = 14695981039346656037ull;
global auto constexpr fnv_prime = 1099511628211ull;
fn Hash hash_bytes(String bytes)
{
u64 result = fnv_offset;
for (u64 i = 0; i < bytes.length; i += 1)
{
result ^= bytes.pointer[i];
result *= fnv_prime;
}
return (Hash)result;
}
// fn forceinline long syscall0(long n)
// {
// unsigned long ret;
// __asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n) : "rcx", "r11", "memory");
// return ret;
// }
fn forceinline long syscall1(long n, long a1)
{
unsigned long ret;
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1) : "rcx", "r11", "memory");
return ret;
}
fn forceinline long syscall2(long n, long a1, long a2)
{
unsigned long ret;
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2)
: "rcx", "r11", "memory");
return ret;
}
fn forceinline long syscall3(long n, long a1, long a2, long a3)
{
unsigned long ret;
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
"d"(a3) : "rcx", "r11", "memory");
return ret;
}
// fn forceinline long syscall4(long n, long a1, long a2, long a3, long a4)
// {
// unsigned long ret;
// register long r10 __asm__("r10") = a4;
// __asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
// "d"(a3), "r"(r10): "rcx", "r11", "memory");
// return ret;
// }
// fn forceinline long syscall5(long n, long a1, long a2, long a3, long a4, long a5)
// {
// unsigned long ret;
// register long r10 __asm__("r10") = a4;
// register long r8 __asm__("r8") = a5;
// __asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
// "d"(a3), "r"(r10), "r"(r8) : "rcx", "r11", "memory");
// return ret;
// }
fn forceinline long syscall6(long n, long a1, long a2, long a3, long a4, long a5, long a6)
{
unsigned long ret;
register long r10 __asm__("r10") = a4;
register long r8 __asm__("r8") = a5;
register long r9 __asm__("r9") = a6;
__asm__ __volatile__ ("syscall" : "=a"(ret) : "a"(n), "D"(a1), "S"(a2),
"d"(a3), "r"(r10), "r"(r8), "r"(r9) : "rcx", "r11", "memory");
return ret;
}
fn u8 memeq(u8* a, u8* b, u64 size)
{
for (u64 i = 0; i < size; i += 1)
{
if (a[i] != b[i])
{
return 0;
}
}
return 1;
}
enum class SyscallX86_64 : u64 {
read = 0,
write = 1,
open = 2,
close = 3,
stat = 4,
fstat = 5,
lstat = 6,
poll = 7,
lseek = 8,
mmap = 9,
mprotect = 10,
munmap = 11,
brk = 12,
rt_sigaction = 13,
rt_sigprocmask = 14,
rt_sigreturn = 15,
ioctl = 16,
pread64 = 17,
pwrite64 = 18,
readv = 19,
writev = 20,
access = 21,
pipe = 22,
select = 23,
sched_yield = 24,
mremap = 25,
msync = 26,
mincore = 27,
madvise = 28,
shmget = 29,
shmat = 30,
shmctl = 31,
dup = 32,
dup2 = 33,
pause = 34,
nanosleep = 35,
getitimer = 36,
alarm = 37,
setitimer = 38,
getpid = 39,
sendfile = 40,
socket = 41,
connect = 42,
accept = 43,
sendto = 44,
recvfrom = 45,
sendmsg = 46,
recvmsg = 47,
shutdown = 48,
bind = 49,
listen = 50,
getsockname = 51,
getpeername = 52,
socketpair = 53,
setsockopt = 54,
getsockopt = 55,
clone = 56,
fork = 57,
vfork = 58,
execve = 59,
exit = 60,
wait4 = 61,
kill = 62,
uname = 63,
semget = 64,
semop = 65,
semctl = 66,
shmdt = 67,
msgget = 68,
msgsnd = 69,
msgrcv = 70,
msgctl = 71,
fcntl = 72,
flock = 73,
fsync = 74,
fdatasync = 75,
truncate = 76,
ftruncate = 77,
getdents = 78,
getcwd = 79,
chdir = 80,
fchdir = 81,
rename = 82,
mkdir = 83,
rmdir = 84,
creat = 85,
link = 86,
unlink = 87,
symlink = 88,
readlink = 89,
chmod = 90,
fchmod = 91,
chown = 92,
fchown = 93,
lchown = 94,
umask = 95,
gettimeofday = 96,
getrlimit = 97,
getrusage = 98,
sysinfo = 99,
times = 100,
ptrace = 101,
getuid = 102,
syslog = 103,
getgid = 104,
setuid = 105,
setgid = 106,
geteuid = 107,
getegid = 108,
setpgid = 109,
getppid = 110,
getpgrp = 111,
setsid = 112,
setreuid = 113,
setregid = 114,
getgroups = 115,
setgroups = 116,
setresuid = 117,
getresuid = 118,
setresgid = 119,
getresgid = 120,
getpgid = 121,
setfsuid = 122,
setfsgid = 123,
getsid = 124,
capget = 125,
capset = 126,
rt_sigpending = 127,
rt_sigtimedwait = 128,
rt_sigqueueinfo = 129,
rt_sigsuspend = 130,
sigaltstack = 131,
utime = 132,
mknod = 133,
uselib = 134,
personality = 135,
ustat = 136,
statfs = 137,
fstatfs = 138,
sysfs = 139,
getpriority = 140,
setpriority = 141,
sched_setparam = 142,
sched_getparam = 143,
sched_setscheduler = 144,
sched_getscheduler = 145,
sched_get_priority_max = 146,
sched_get_priority_min = 147,
sched_rr_get_interval = 148,
mlock = 149,
munlock = 150,
mlockall = 151,
munlockall = 152,
vhangup = 153,
modify_ldt = 154,
pivot_root = 155,
_sysctl = 156,
prctl = 157,
arch_prctl = 158,
adjtimex = 159,
setrlimit = 160,
chroot = 161,
sync = 162,
acct = 163,
settimeofday = 164,
mount = 165,
umount2 = 166,
swapon = 167,
swapoff = 168,
reboot = 169,
sethostname = 170,
setdomainname = 171,
iopl = 172,
ioperm = 173,
create_module = 174,
init_module = 175,
delete_module = 176,
get_kernel_syms = 177,
query_module = 178,
quotactl = 179,
nfsservctl = 180,
getpmsg = 181,
putpmsg = 182,
afs_syscall = 183,
tuxcall = 184,
security = 185,
gettid = 186,
readahead = 187,
setxattr = 188,
lsetxattr = 189,
fsetxattr = 190,
getxattr = 191,
lgetxattr = 192,
fgetxattr = 193,
listxattr = 194,
llistxattr = 195,
flistxattr = 196,
removexattr = 197,
lremovexattr = 198,
fremovexattr = 199,
tkill = 200,
time = 201,
futex = 202,
sched_setaffinity = 203,
sched_getaffinity = 204,
set_thread_area = 205,
io_setup = 206,
io_destroy = 207,
io_getevents = 208,
io_submit = 209,
io_cancel = 210,
get_thread_area = 211,
lookup_dcookie = 212,
epoll_create = 213,
epoll_ctl_old = 214,
epoll_wait_old = 215,
remap_file_pages = 216,
getdents64 = 217,
set_tid_address = 218,
restart_syscall = 219,
semtimedop = 220,
fadvise64 = 221,
timer_create = 222,
timer_settime = 223,
timer_gettime = 224,
timer_getoverrun = 225,
timer_delete = 226,
clock_settime = 227,
clock_gettime = 228,
clock_getres = 229,
clock_nanosleep = 230,
exit_group = 231,
epoll_wait = 232,
epoll_ctl = 233,
tgkill = 234,
utimes = 235,
vserver = 236,
mbind = 237,
set_mempolicy = 238,
get_mempolicy = 239,
mq_open = 240,
mq_unlink = 241,
mq_timedsend = 242,
mq_timedreceive = 243,
mq_notify = 244,
mq_getsetattr = 245,
kexec_load = 246,
waitid = 247,
add_key = 248,
request_key = 249,
keyctl = 250,
ioprio_set = 251,
ioprio_get = 252,
inotify_init = 253,
inotify_add_watch = 254,
inotify_rm_watch = 255,
migrate_pages = 256,
openat = 257,
mkdirat = 258,
mknodat = 259,
fchownat = 260,
futimesat = 261,
fstatat64 = 262,
unlinkat = 263,
renameat = 264,
linkat = 265,
symlinkat = 266,
readlinkat = 267,
fchmodat = 268,
faccessat = 269,
pselect6 = 270,
ppoll = 271,
unshare = 272,
set_robust_list = 273,
get_robust_list = 274,
splice = 275,
tee = 276,
sync_file_range = 277,
vmsplice = 278,
move_pages = 279,
utimensat = 280,
epoll_pwait = 281,
signalfd = 282,
timerfd_create = 283,
eventfd = 284,
fallocate = 285,
timerfd_settime = 286,
timerfd_gettime = 287,
accept4 = 288,
signalfd4 = 289,
eventfd2 = 290,
epoll_create1 = 291,
dup3 = 292,
pipe2 = 293,
inotify_init1 = 294,
preadv = 295,
pwritev = 296,
rt_tgsigqueueinfo = 297,
perf_event_open = 298,
recvmmsg = 299,
fanotify_init = 300,
fanotify_mark = 301,
prlimit64 = 302,
name_to_handle_at = 303,
open_by_handle_at = 304,
clock_adjtime = 305,
syncfs = 306,
sendmmsg = 307,
setns = 308,
getcpu = 309,
process_vm_readv = 310,
process_vm_writev = 311,
kcmp = 312,
finit_module = 313,
sched_setattr = 314,
sched_getattr = 315,
renameat2 = 316,
seccomp = 317,
getrandom = 318,
memfd_create = 319,
kexec_file_load = 320,
bpf = 321,
execveat = 322,
userfaultfd = 323,
membarrier = 324,
mlock2 = 325,
copy_file_range = 326,
preadv2 = 327,
pwritev2 = 328,
pkey_mprotect = 329,
pkey_alloc = 330,
pkey_free = 331,
statx = 332,
io_pgetevents = 333,
rseq = 334,
pidfd_send_signal = 424,
io_uring_setup = 425,
io_uring_enter = 426,
io_uring_register = 427,
open_tree = 428,
move_mount = 429,
fsopen = 430,
fsconfig = 431,
fsmount = 432,
fspick = 433,
pidfd_open = 434,
clone3 = 435,
close_range = 436,
openat2 = 437,
pidfd_getfd = 438,
faccessat2 = 439,
process_madvise = 440,
epoll_pwait2 = 441,
mount_setattr = 442,
quotactl_fd = 443,
landlock_create_ruleset = 444,
landlock_add_rule = 445,
landlock_restrict_self = 446,
memfd_secret = 447,
process_mrelease = 448,
futex_waitv = 449,
set_mempolicy_home_node = 450,
cachestat = 451,
fchmodat2 = 452,
map_shadow_stack = 453,
futex_wake = 454,
futex_wait = 455,
futex_requeue = 456,
};
fn void* syscall_mmap(void* address, size_t length, int protection_flags, int map_flags, int fd, __off_t offset)
{
return (void*) syscall6(static_cast<long>(SyscallX86_64::mmap), (unsigned long)address, length, protection_flags, map_flags, fd, offset);
}
fn int syscall_mprotect(void *address, size_t length, int protection_flags)
{
return syscall3(static_cast<long>(SyscallX86_64::mprotect), (unsigned long)address, length, protection_flags);
}
fn int syscall_open(const char *file_path, int flags, int mode)
{
return syscall3(static_cast<long>(SyscallX86_64::open), (unsigned long)file_path, flags, mode);
}
fn int syscall_fstat(int fd, struct stat *buffer)
{
return syscall2(static_cast<long>(SyscallX86_64::fstat), fd, (unsigned long)buffer);
}
fn ssize_t syscall_read(int fd, void* buffer, size_t bytes)
{
return syscall3(static_cast<long>(SyscallX86_64::read), fd, (unsigned long)buffer, bytes);
}
fn ssize_t syscall_write(int fd, const void *buffer, size_t bytes)
{
return syscall3(static_cast<long>(SyscallX86_64::write), fd, (unsigned long)buffer, bytes);
}
[[noreturn]] [[gnu::cold]] fn void syscall_exit(int status)
{
(void)syscall1(231, status);
trap();
}
[[noreturn]] [[gnu::cold]] fn void fail()
{
trap();
syscall_exit(1);
}
fn void* reserve(u64 size, u8 huge_pages)
{
int protection_flags = PROT_NONE;
int map_flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE | (huge_pages ? MAP_HUGETLB : 0);
void* result = syscall_mmap(0, size, protection_flags, map_flags, -1, 0);
assert(result != MAP_FAILED);
return result;
}
fn void commit(void* address, u64 size)
{
int result = syscall_mprotect(address, size, PROT_READ | PROT_WRITE);
assert(result == 0);
}
fn u64 align_forward(u64 value, u64 alignment)
{
u64 mask = alignment - 1;
u64 result = (value + mask) & ~mask;
return result;
}
struct Arena
{
u64 reserved_size;
u64 commited;
u64 commit_position;
u64 granularity;
u8 reserved[4 * 8];
global auto constexpr minimum_granularity = KB(4);
global auto constexpr middle_granularity = MB(2);
global auto constexpr page_granularity = page_size;
global auto constexpr default_size = GB(4);
fn Arena* init(u64 reserved_size, u64 granularity, u64 initial_size)
{
assert(initial_size % granularity == 0);
Arena* arena = (Arena*)reserve(reserved_size, granularity != minimum_granularity);
commit(arena, initial_size);
*arena = {
.reserved_size = reserved_size,
.commited = initial_size,
.commit_position = sizeof(Arena),
.granularity = granularity,
};
return arena;
}
fn Arena* init_default(u64 initial_size)
{
return init(default_size, minimum_granularity, initial_size);
}
void* allocate_bytes(u64 size, u64 alignment)
{
u64 aligned_offset = align_forward(commit_position, alignment);
u64 aligned_size_after = aligned_offset + size;
if (aligned_size_after <= commited)
{
void* result = (u8*)this + aligned_offset;
commit_position = aligned_size_after;
return result;
}
else
{
trap();
}
}
template<typename T>
T* allocate_many(u64 count)
{
return (T*)allocate_bytes(sizeof(T) * count, alignof(T));
}
template<typename T>
T* allocate_one()
{
return allocate_many<T>(1);
}
template<typename T>
T* allocate_slice(u64 count)
{
return {
.pointer = allocate_many<T>(count),
.length = count,
};
}
};
static_assert(sizeof(Arena) == 64, "Arena must be cache aligned");
template<typename Destination, typename Source>
fn forceinline Destination transmute(Source source)
{
static_assert(sizeof(Source) == sizeof(Destination));
return *(Destination*)&source;
}
fn String file_read(Arena* arena, String path)
{
String result = {};
int file_descriptor = syscall_open((char*)path.pointer, 0, 0);
assert(file_descriptor != -1);
struct stat stat_buffer;
int stat_result = syscall_fstat(file_descriptor, &stat_buffer);
assert(stat_result == 0);
u64 file_size = stat_buffer.st_size;
result = {
.pointer = (u8*)arena->allocate_bytes(file_size, 64),
.length = file_size,
};
// TODO: big files
ssize_t read_result = syscall_read(file_descriptor, result.pointer, result.length);
assert(read_result >= 0);
assert((u64)read_result == file_size);
return result;
}
fn void print(String message)
{
ssize_t result = syscall_write(1, message.pointer, message.length);
assert(result >= 0);
assert((u64)result == message.length);
}
template<typename T> struct PinnedArray;
fn void generic_pinned_array_ensure_capacity(PinnedArray<u8>* array, u32 additional_T, u32 size_of_T);
fn u8* generic_pinned_array_add_with_capacity(PinnedArray<u8>* array, u32 additional_T, u32 size_of_T);
template <typename T>
struct PinnedArray
{
T* pointer;
u32 length;
u32 committed;
global constexpr auto granularity = page_size;
global constexpr auto reserved_size = ((u64)GB(4) - granularity);
forceinline T& operator[](u32 index)
{
assert(index < length);
return pointer[index];
}
forceinline void ensure_capacity(u32 additional)
{
auto generic_array = (PinnedArray<u8>*)(this);
generic_pinned_array_ensure_capacity(generic_array, additional, sizeof(T));
}
forceinline Slice<T> add_with_capacity(u32 additional)
{
auto generic_array = (PinnedArray<u8>*)(this);
auto pointer = generic_pinned_array_add_with_capacity(generic_array, additional, sizeof(T));
return {
.pointer = (T*)pointer,
.length = additional,
};
}
// generic_pinned_array_ensure_capacity(array, additional_T, size_of_T);
// u8* result = generic_pinned_array_add_with_capacity(array, additional_T, size_of_T);
forceinline Slice<T> add(u32 additional)
{
ensure_capacity(additional);
auto slice = add_with_capacity(additional);
return slice;
}
forceinline T* add_one()
{
return add(1).pointer;
}
};
forceinline fn u32 generic_pinned_array_length(PinnedArray<u8>* array, u32 size_of_T)
{
u32 current_length_bytes = array->length * size_of_T;
return current_length_bytes;
}
fn void generic_pinned_array_ensure_capacity(PinnedArray<u8>* array, u32 additional_T, u32 size_of_T)
{
if (array->committed == 0)
{
assert(array->length == 0);
assert(array->pointer == 0);
array->pointer = static_cast<u8*>(reserve(PinnedArray<u8>::reserved_size, 0));
}
u32 additional_bytes = additional_T * size_of_T;
u32 current_length_bytes = generic_pinned_array_length(array, size_of_T);
u64 granularity_aligned_commit_bytes = align_forward(current_length_bytes, PinnedArray<u8>::granularity);
u64 new_length_bytes = current_length_bytes + additional_bytes;
if (granularity_aligned_commit_bytes < new_length_bytes)
{
assert(new_length_bytes <= PinnedArray<u8>::reserved_size);
u64 new_granularity_aligned_commit_bytes = align_forward(new_length_bytes, PinnedArray<u8>::granularity);
u8* commit_pointer = array->pointer + granularity_aligned_commit_bytes;
u64 commit_bytes = new_granularity_aligned_commit_bytes + granularity_aligned_commit_bytes;
commit(commit_pointer, commit_bytes);
array->committed += commit_bytes / PinnedArray<u8>::granularity;
}
}
fn u8* generic_pinned_array_add_with_capacity(PinnedArray<u8>* array, u32 additional_T, u32 size_of_T)
{
u32 current_length_bytes = generic_pinned_array_length(array, size_of_T);
assert(current_length_bytes < PinnedArray<u8>::reserved_size);
u8* pointer = array->pointer;
array->length += additional_T;
return pointer;
}
template <typename K, typename V> struct PinnedHashmap;
template <typename K, typename V>
struct GetOrPut
{
K* key;
V* value;
u8 existing;
};
fn GetOrPut<u8, u8> generic_pinned_hashmap_get_or_put(PinnedHashmap<u8, u8>* hashmap, u8* new_key_pointer, u32 key_size, u8* new_value_pointer, u32 value_size);
template<typename K, typename V>
struct PinnedHashmap
{
K* keys;
V* values;
u32 length;
u16 key_page_capacity;
u16 value_page_capacity;
global constexpr auto invalid_index = ~0u;
global constexpr auto granularity = PinnedArray<V>::granularity;
global constexpr auto reserved_size = PinnedArray<V>::reserved_size;
static_assert(granularity % sizeof(K) == 0, "");
static_assert(granularity % sizeof(V) == 0, "");
forceinline GetOrPut<K, V> get_or_put(K key, V value)
{
auto* generic_hashmap = (PinnedHashmap<u8, u8>*)(this);
auto generic_get_or_put = generic_pinned_hashmap_get_or_put(generic_hashmap, (u8*)&key, sizeof(K), (u8*)&value, sizeof(V));
return *(GetOrPut<K, V>*)&generic_get_or_put;
}
};
// Returns the generic value pointer if the key is present
fn u32 generic_pinned_hashmap_get_index(PinnedHashmap<u8, u8>* hashmap, u8* key_pointer, u32 key_size)
{
u32 index = hashmap->invalid_index;
for (u32 i = 0; i < hashmap->length; i += 1)
{
u8* it_key_pointer = &hashmap->keys[i * key_size];
if (memeq(it_key_pointer, key_pointer, key_size))
{
index = (it_key_pointer - hashmap->keys) / key_size;
break;
}
}
return index;
}
fn void generic_pinned_hashmap_ensure_capacity(PinnedHashmap<u8, u8>* hashmap, u32 key_size, u32 value_size, u32 additional_elements)
{
if (additional_elements != 0)
{
if (hashmap->key_page_capacity == 0)
{
assert(hashmap->value_page_capacity == 0);
hashmap->keys = (u8*)reserve(hashmap->reserved_size, 0);
hashmap->values = (u8*)reserve(hashmap->reserved_size, 0);
}
u32 target_element_capacity = hashmap->length + additional_elements;
{
u32 key_byte_capacity = hashmap->key_page_capacity * hashmap->granularity;
u32 target_byte_capacity = target_element_capacity * key_size;
if (key_byte_capacity < target_byte_capacity)
{
u32 aligned_target_byte_capacity = align_forward(target_byte_capacity, hashmap->granularity);
void* commit_pointer = hashmap->keys + key_byte_capacity;
u32 commit_size = aligned_target_byte_capacity - key_byte_capacity;
commit(commit_pointer, commit_size);
hashmap->key_page_capacity = aligned_target_byte_capacity / hashmap->granularity;
}
}
{
u32 value_byte_capacity = hashmap->value_page_capacity * hashmap->granularity;
u32 target_byte_capacity = target_element_capacity * value_size;
if (value_byte_capacity < target_byte_capacity)
{
u32 aligned_target_byte_capacity = align_forward(target_byte_capacity, hashmap->granularity);
void* commit_pointer = hashmap->values + value_byte_capacity;
u32 commit_size = aligned_target_byte_capacity - value_byte_capacity;
commit(commit_pointer, commit_size);
hashmap->value_page_capacity = aligned_target_byte_capacity / hashmap->granularity;
}
}
}
}
fn GetOrPut<u8, u8> generic_pinned_hashmap_get_or_put(PinnedHashmap<u8, u8>* hashmap, u8* new_key_pointer, u32 key_size, u8* new_value_pointer, u32 value_size)
{
u32 index = generic_pinned_hashmap_get_index(hashmap, new_key_pointer, key_size);
if (index != hashmap->invalid_index)
{
trap();
}
else
{
generic_pinned_hashmap_ensure_capacity(hashmap, key_size, value_size, 1);
u32 new_index = hashmap->length;
hashmap->length += 1;
u8* key_pointer = &hashmap->keys[new_index * key_size];
u8* value_pointer = &hashmap->values[new_index * value_size];
memcpy(key_pointer, new_key_pointer, key_size);
memcpy(value_pointer, new_value_pointer, value_size);
return {
.key = key_pointer,
.value = value_pointer,
.existing = 0,
};
}
}
typedef enum FileStatus
{
FILE_STATUS_ADDED = 0,
FILE_STATUS_QUEUED = 1,
FILE_STATUS_READ = 2,
FILE_STATUS_ANALYZING = 3,
} FileStatus;
struct File
{
String path;
String source_code;
FileStatus status;
};
struct SemaType;
union Type
{
enum Id
{
sema,
backend,
};
u64 bits:57;
Id id:1;
forceinline SemaType* get_sema()
{
assert(id == Id::sema);
return (SemaType*)(bits);
}
forceinline u8 is_resolved();
};
static_assert(sizeof(Type) == 8);
enum class SemaTypeId: u8
{
VOID,
NORETURN,
POINTER,
INTEGER,
ARRAY,
STRUCT,
UNION,
COUNT,
};
global auto constexpr type_id_bit_count = 3;
static_assert(static_cast<u8>(SemaTypeId::COUNT) < (1 << type_id_bit_count), "Type bit count for id must be respected");
global auto constexpr type_flags_bit_count = 32 - (type_id_bit_count + 1);
struct SemaType
{
u64 size;
u64 alignment;
SemaTypeId id : type_id_bit_count;
u32 resolved: 1;
u32 flags: type_flags_bit_count;
u32 name;
u8 get_bit_count()
{
assert(id == SemaTypeId::INTEGER);
u32 bit_count_mask = (1 << (type_flags_bit_count - 1)) - 1;
u8 bit_count = flags & bit_count_mask;
assert(bit_count <= size * 8);
assert(bit_count <= 64);
return bit_count;
}
};
static_assert(sizeof(SemaType) == sizeof(u64) * 3, "Type must be 24 bytes");
forceinline u8 Type::is_resolved()
{
return (id == Id::backend) | ((id == Id::sema) & get_sema()->resolved);
}
struct Symbol
{
enum class Id: u8
{
variable,
function,
};
enum class Linkage: u8
{
internal,
external,
};
u32 name;
Id id: 1;
Linkage linkage: 1;
};
typedef enum AbiInfoKind : u8
{
ABI_INFO_IGNORE,
ABI_INFO_DIRECT,
ABI_INFO_DIRECT_PAIR,
ABI_INFO_DIRECT_COERCE,
ABI_INFO_DIRECT_COERCE_INT,
ABI_INFO_DIRECT_SPLIT_STRUCT_I32,
ABI_INFO_EXPAND_COERCE,
ABI_INFO_INDIRECT,
ABI_INFO_EXPAND,
} AbiInfoKind;
enum class Side : u8
{
left,
right,
};
struct NodeDataType
{
enum class Id : u8
{
VOID,
INTEGER,
TUPLE,
CONTROL,
MEMORY,
POINTER,
};
Id id;
u8 bit_count:5;
};
union AbiInfoPayload
{
NodeDataType direct;
NodeDataType direct_pair[2];
NodeDataType direct_coerce;
struct
{
NodeDataType type;
u32 alignment;
} indirect;
};
typedef union AbiInfoPayload AbiInfoPayload;
struct AbiInfoAttributes
{
u8 by_reg: 1;
u8 zero_extend: 1;
u8 sign_extend: 1;
u8 realign: 1;
u8 by_value: 1;
};
typedef struct AbiInfoAttributes AbiInfoAttributes;
struct AbiInfo
{
AbiInfoPayload payload;
u16 indices[2];
AbiInfoAttributes attributes;
AbiInfoKind kind;
};
struct FunctionPrototype
{
AbiInfo* argument_type_abis; // The count for this array is "original_argument_count", not "abi_argument_count"
SemaType** original_argument_types;
// TODO: are these needed?
// Node::DataType* abi_argument_types;
// u32 abi_argument_count;
SemaType* original_return_type;
AbiInfo return_type_abi;
u32 original_argument_count;
// TODO: is this needed?
// Node::DataType abi_return_type;
u8 varags:1;
};
struct Function;
global auto constexpr void_type_index = 0;
global auto constexpr noreturn_type_index = 1;
global auto constexpr opaque_pointer_type_index = 2;
// global auto constexpr f32_type_offset = 3;
// global auto constexpr f64_type_offset = 4;
global auto constexpr integer_type_offset = 5;
global auto constexpr integer_type_count = 64 * 2;
global auto constexpr builtin_type_count = integer_type_count + integer_type_offset + 1;
struct Unit
{
PinnedArray<File> files;
PinnedArray<Function> functions;
Arena* arena;
Arena* node_arena;
Arena* type_arena;
PinnedHashmap<Hash, String> identifiers;
SemaType* builtin_types;
u64 generate_debug_information : 1;
SemaType* get_integer_type(u8 bit_count, u8 signedness)
{
auto index = integer_type_offset + signedness * 64 + bit_count - 1;
return &builtin_types[index];
}
};
struct Node;
struct Function
{
Symbol symbol;
Node* root_node;
Node** parameters;
FunctionPrototype prototype;
u32 node_count;
u16 parameter_count;
};
struct ProjectionData
{
NodeDataType type;
u16 index;
};
// This is a node in the "sea of nodes" sense:
// https://en.wikipedia.org/wiki/Sea_of_nodes
struct Node
{
enum class Id: u8
{
ROOT,
PROJECTION,
RETURN,
CONSTANT_INT,
};
static_assert(sizeof(NodeDataType) <= 2);
Node** edges;
u32 gvn;
u16 input_count;
u16 output_count;
u16 capacity;
NodeDataType data_type;
Id id;
union
{
struct
{
u32 index;
} projection;
u64 constant_int;
};
forceinline Slice<Node*> get_inputs()
{
return {
.pointer = edges,
.length = input_count,
};
}
forceinline Slice<Node*> get_outputs()
{
return {
.pointer = edges + input_count,
.length = output_count,
};
}
[[nodiscard]] fn Node* add(Unit* unit)
{
Node* node = unit->node_arena->allocate_one<Node>();
*node = {};
return node;
}
[[nodiscard]] fn Node* add_from_function(Unit* unit, Function* function)
{
u32 gvn = function->node_count;
function->node_count += 1;
Node* node = unit->node_arena->allocate_one<Node>();
*node = {
.gvn = gvn,
};
return node;
}
Node* project(Unit* unit, Function* function, ProjectionData data)
{
assert(data_type.id == NodeDataType::Id::TUPLE);
Node* projection = Node::add_from_function(unit, function);
assert(projection != this);
projection->id = Node::Id::PROJECTION;
projection->data_type = data.type;
projection->reallocate_edges(unit, 4);
projection->input_count = 1;
projection->set_input(unit, function, this, 0);
projection->projection.index = data.index;
return projection;
}
void set_input(Unit* unit, Function* function, Node* input, u16 slot)
{
assert(slot < input_count);
remove_output(unit, function, slot);
*get_input_slot(slot) = input;
if (input)
{
add_output(unit, function, input);
}
}
Node** get_output_slot(u16 slot)
{
assert(slot < output_count);
return edges + input_count + slot;
}
Node** get_input_slot(u16 slot)
{
assert(slot < input_count);
return edges + slot;
}
void add_output(Unit* unit, Function* function, Node* input)
{
unused(unit);
unused(function);
if (input->output_count + input->input_count >= input->capacity)
{
trap();
}
auto index = input->output_count;
input->output_count += 1;
*input->get_output_slot(index) = this;
}
void remove_output(Unit* unit, Function* function, u16 slot)
{
unused(unit);
unused(function);
if (slot < output_count)
{
Node** output_slot = get_output_slot(slot);
if (*output_slot)
{
trap();
}
}
}
void reallocate_edges(Unit* unit, u16 new_capacity)
{
auto old_capacity = capacity;
assert(new_capacity > old_capacity);
auto length = output_count + input_count;
Node** new_edges = unit->arena->allocate_many<Node*>(new_capacity);
memcpy(new_edges, edges, length * sizeof(Node*));
memset(new_edges + length, 0, (new_capacity - length) * sizeof(Node));
capacity = new_capacity;
edges = new_edges;
// TODO: free
}
};
fn u64 round_up_to_next_power_of_2(u64 n)
{
n -= 1;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n |= n >> 32;
n += 1;
return n;
}
fn Hash intern_identifier(Unit* unit, String identifier)
{
Hash hash = hash_bytes(identifier);
(void)unit->identifiers.get_or_put(hash, identifier);
return hash;
}
global String integer_names[] =
{
strlit("u1"),
strlit("u2"),
strlit("u3"),
strlit("u4"),
strlit("u5"),
strlit("u6"),
strlit("u7"),
strlit("u8"),
strlit("u9"),
strlit("u10"),
strlit("u11"),
strlit("u12"),
strlit("u13"),
strlit("u14"),
strlit("u15"),
strlit("u16"),
strlit("u17"),
strlit("u18"),
strlit("u19"),
strlit("u20"),
strlit("u21"),
strlit("u22"),
strlit("u23"),
strlit("u24"),
strlit("u25"),
strlit("u26"),
strlit("u27"),
strlit("u28"),
strlit("u29"),
strlit("u30"),
strlit("u31"),
strlit("u32"),
strlit("u33"),
strlit("u34"),
strlit("u35"),
strlit("u36"),
strlit("u37"),
strlit("u38"),
strlit("u39"),
strlit("u40"),
strlit("u41"),
strlit("u42"),
strlit("u43"),
strlit("u44"),
strlit("u45"),
strlit("u46"),
strlit("u47"),
strlit("u48"),
strlit("u49"),
strlit("u50"),
strlit("u51"),
strlit("u52"),
strlit("u53"),
strlit("u54"),
strlit("u55"),
strlit("u56"),
strlit("u57"),
strlit("u58"),
strlit("u59"),
strlit("u60"),
strlit("u61"),
strlit("u62"),
strlit("u63"),
strlit("u64"),
strlit("s1"),
strlit("s2"),
strlit("s3"),
strlit("s4"),
strlit("s5"),
strlit("s6"),
strlit("s7"),
strlit("s8"),
strlit("s9"),
strlit("s10"),
strlit("s11"),
strlit("s12"),
strlit("s13"),
strlit("s14"),
strlit("s15"),
strlit("s16"),
strlit("s17"),
strlit("s18"),
strlit("s19"),
strlit("s20"),
strlit("s21"),
strlit("s22"),
strlit("s23"),
strlit("s24"),
strlit("s25"),
strlit("s26"),
strlit("s27"),
strlit("s28"),
strlit("s29"),
strlit("s30"),
strlit("s31"),
strlit("s32"),
strlit("s33"),
strlit("s34"),
strlit("s35"),
strlit("s36"),
strlit("s37"),
strlit("s38"),
strlit("s39"),
strlit("s40"),
strlit("s41"),
strlit("s42"),
strlit("s43"),
strlit("s44"),
strlit("s45"),
strlit("s46"),
strlit("s47"),
strlit("s48"),
strlit("s49"),
strlit("s50"),
strlit("s51"),
strlit("s52"),
strlit("s53"),
strlit("s54"),
strlit("s55"),
strlit("s56"),
strlit("s57"),
strlit("s58"),
strlit("s59"),
strlit("s60"),
strlit("s61"),
strlit("s62"),
strlit("s63"),
strlit("s64"),
};
fn void unit_initialize(Unit* unit)
{
Arena* type_arena = Arena::init(Arena::default_size, Arena::minimum_granularity, KB(64));
SemaType* builtin_types = type_arena->allocate_many<SemaType>(builtin_type_count);
*unit = {
.arena = Arena::init(Arena::default_size, Arena::minimum_granularity, KB(4)),
.node_arena = Arena::init(Arena::default_size, Arena::minimum_granularity, KB(64)),
.type_arena = type_arena,
.builtin_types = builtin_types,
};
builtin_types[void_type_index] = {
.size = 0,
.alignment = 1,
.id = SemaTypeId::VOID,
.resolved = 1,
.name = intern_identifier(unit, strlit("void")),
};
builtin_types[noreturn_type_index] = {
.size = 0,
.alignment = 1,
.id = SemaTypeId::NORETURN,
.resolved = 1,
.name = intern_identifier(unit, strlit("noreturn")),
};
builtin_types[opaque_pointer_type_index] = {
.size = 8,
.alignment = 8,
.id = SemaTypeId::POINTER,
.resolved = 1,
.name = intern_identifier(unit, strlit("*any")),
};
// TODO: float types
u64 i;
for (i = integer_type_offset; i < integer_type_offset + 64; i += 1)
{
u64 bit_count = i - integer_type_offset + 1;
assert(bit_count >= 1 | bit_count <= 64);
auto aligned_bit_count = round_up_to_next_power_of_2(bit_count);
auto byte_count = max<u64>(aligned_bit_count / 8, 1);
assert(byte_count <= bit_count);
assert(byte_count == 1 | byte_count == 2 | byte_count == 4 | byte_count == 8);
builtin_types[i] =
{
.size = byte_count,
.alignment = byte_count,
.id = SemaTypeId::INTEGER,
.resolved = 1,
.flags = static_cast<u32>(bit_count),
.name = intern_identifier(unit, integer_names[bit_count - 1]),
};
}
for (; i < integer_type_offset + integer_type_count; i += 1)
{
u64 bit_count = i - (integer_type_offset + 64 - 1);
assert(bit_count >= 1 | bit_count <= 64);
auto aligned_bit_count = round_up_to_next_power_of_2(bit_count);
auto byte_count = max<u64>(aligned_bit_count / 8, 1);
assert(byte_count <= bit_count);
assert(byte_count == 1 | byte_count == 2 | byte_count == 4 | byte_count == 8);
builtin_types[i] =
{
.size = byte_count,
.alignment = byte_count,
.id = SemaTypeId::INTEGER,
.resolved = 1,
.flags = static_cast<u32>(bit_count | (1 << (type_flags_bit_count - 1))), // Signedness bit
.name = intern_identifier(unit, integer_names[bit_count + 63]),
};
}
}
static_assert(array_length(integer_names) == 128, "Integer name array must be 128 bytes");
struct Instance
{
Arena* arena;
};
typedef struct Instance Instance;
fn Unit* instance_add_unit(Instance* instance)
{
Unit* unit = instance->arena->allocate_one<Unit>();
*unit = {
};
return unit;
}
struct Parser
{
u64 i;
u32 line;
u32 column;
};
typedef struct Parser Parser;
fn u64 safe_flag(u64 value, u64 flag)
{
u64 result = value & ((u64)0 - flag);
return result;
}
fn u8 get_next_ch_safe(String file, u64 index)
{
u64 next_index = index + 1;
u64 is_in_range = next_index < file.length;
u64 safe_index = safe_flag(next_index, is_in_range);
u8 unsafe_result = file.pointer[safe_index];
u64 safe_result = safe_flag(unsafe_result, is_in_range);
assert(safe_result < 256);
return (u8)safe_result;
}
fn u32 is_space(u8 ch, u8 next_ch)
{
u32 is_comment = (ch == '/') & (next_ch == '/');
u32 is_whitespace = ch == ' ';
u32 is_vertical_tab = ch == 0x0b;
u32 is_horizontal_tab = ch == '\t';
u32 is_line_feed = ch == '\n';
u32 is_carry_return = ch == '\r';
u32 result = (((is_vertical_tab | is_horizontal_tab) | (is_line_feed | is_carry_return)) | (is_comment | is_whitespace));
return result;
}
fn void skip_space(Parser* parser, String src)
{
u64 original_i = parser->i;
if (original_i != src.length)
{
if (is_space(src.pointer[original_i], get_next_ch_safe(src, original_i)))
{
while (parser->i < src.length)
{
u64 index = parser->i;
u8 ch = src.pointer[index];
u64 new_line = ch == '\n';
parser->line += new_line;
if (new_line)
{
parser->column = index + 1;
}
if (!is_space(ch, get_next_ch_safe(src, parser->i)))
{
break;
}
u32 is_comment = src.pointer[index] == '/';
parser->i += is_comment + is_comment;
if (is_comment)
{
while (parser->i < src.length)
{
if (src.pointer[parser->i] == '\n')
{
break;
}
parser->i += 1;
}
continue;
}
parser->i += 1;
}
}
}
}
fn u64 is_lower(u8 ch)
{
return (ch >= 'a') & (ch <= 'z');
}
fn u64 is_upper(u8 ch)
{
return (ch >= 'A') & (ch <= 'Z');
}
fn u64 is_alphabetic(u8 ch)
{
return is_lower(ch) | is_upper(ch);
}
fn u64 is_decimal_digit(u8 ch)
{
return (ch >= '0') & (ch <= '9');
}
fn u64 is_hex_digit(u8 ch)
{
return (is_decimal_digit(ch) | ((ch == 'a' | ch == 'A') | (ch == 'b' | ch == 'B'))) | (((ch == 'c' | ch == 'C') | (ch == 'd' | ch == 'D')) | ((ch == 'e' | ch == 'E') | (ch == 'f' | ch == 'F')));
}
fn u64 is_identifier_start(u8 ch)
{
u64 alphabetic = is_alphabetic(ch);
u64 is_underscore = ch == '_';
return alphabetic | is_underscore;
}
fn u64 is_identifier_ch(u8 ch)
{
u64 identifier_start = is_identifier_start(ch);
u64 decimal = is_decimal_digit(ch);
return identifier_start | decimal;
}
fn void expect_character(Parser* parser, String src, u8 expected_ch)
{
u64 index = parser->i;
if (expect(index < src.length, 1))
{
u8 ch = src.pointer[index];
u64 matches = ch == expected_ch;
expect(matches, 1);
parser->i += matches;
if (!matches)
{
print(strlit("expected character '"));
print(ch_to_str(expected_ch));
print(strlit("', but found '"));
print(ch_to_str(ch));
print(strlit("'\n"));
fail();
}
}
else
{
print(strlit("expected character '"));
print(ch_to_str(expected_ch));
print(strlit("', but found end of file\n"));
fail();
}
}
fn String parse_identifier(Parser* parser, String src)
{
u64 identifier_start_index = parser->i;
u64 is_string_literal = src.pointer[identifier_start_index] == '"';
parser->i += is_string_literal;
u8 identifier_start_ch = src.pointer[parser->i];
u64 is_valid_identifier_start = is_identifier_start(identifier_start_ch);
parser->i += is_valid_identifier_start;
if (expect(is_valid_identifier_start, 1))
{
while (parser->i < src.length)
{
u8 ch = src.pointer[parser->i];
u64 is_identifier = is_identifier_ch(ch);
expect(is_identifier, 1);
parser->i += is_identifier;
if (!is_identifier)
{
if (expect(is_string_literal, 0))
{
expect_character(parser, src, '"');
}
String result = src.slice(identifier_start_index, parser->i - is_string_literal);
return result;
}
}
fail();
}
else
{
fail();
}
}
typedef enum Keyword : u32
{
KEYWORD_COUNT,
KEYWORD_INVALID = ~0u,
} Keyword;
// TODO:
// fn Keyword parse_keyword(String identifier)
// {
// Keyword result = KEYWORD_INVALID;
// return result;
// }
fn Hash parse_and_intern_identifier(Parser* parser, Unit* unit, String src)
{
String identifier = parse_identifier(parser, src);
// Keyword keyword_index = parse_keyword(identifier);
// if (expect(keyword_index != KEYWORD_INVALID, 0))
// {
// fail();
// }
if (expect(identifier.equal(strlit("_")), 0))
{
return 0;
}
Hash result = intern_identifier(unit, identifier);
return result;
}
// fn u32 get_line(Parser* parser)
// {
// return parser->line + 1;
// }
//
// fn u32 get_column(Parser* parser)
// {
// return parser->i - parser->column + 1;
// }
fn File* unit_add_file(Unit* unit, String file_path)
{
auto* file = unit->files.add_one();
*file = {
.path = file_path,
};
return file;
}
fn void unit_file_read(Unit* unit, File* file)
{
assert(file->status == FILE_STATUS_ADDED || file->status == FILE_STATUS_QUEUED);
file->source_code = file_read(unit->arena, file->path);
file->status = FILE_STATUS_READ;
}
global constexpr auto brace_open = '{';
global constexpr auto brace_close = '}';
global constexpr auto parenthesis_open = '(';
global constexpr auto parenthesis_close = ')';
global constexpr auto bracket_open = '[';
global constexpr auto bracket_close = ']';
global constexpr auto pointer_sign = '*';
global constexpr auto end_of_statement = ';';
global constexpr auto end_of_argument = ',';
global constexpr auto function_argument_start = parenthesis_open;
global constexpr auto function_argument_end = parenthesis_close;
global constexpr auto function_attribute_start = bracket_open;
global constexpr auto function_attribute_end = bracket_close;
global constexpr auto symbol_attribute_start = bracket_open;
global constexpr auto symbol_attribute_end = bracket_close;
global constexpr auto block_start = brace_open;
global constexpr auto block_end = brace_close;
global constexpr auto array_expression_start = bracket_open;
// global constexpr auto array_expression_end = bracket_close;
global constexpr auto composite_initialization_start = brace_open;
// global constexpr auto composite_initialization_end = brace_close;
global String function_attributes[] =
{
strlit("cc"),
};
typedef enum FunctionAttribute
{
FUNCTION_ATTRIBUTE_CC,
FUNCTION_ATTRIBUTE_COUNT,
} FunctionAttribute;
static_assert(array_length(function_attributes) == FUNCTION_ATTRIBUTE_COUNT, "");
global String calling_conventions[] =
{
strlit("c"),
strlit("custom"),
};
typedef enum CallingConvention
{
CALLING_CONVENTION_C,
CALLING_CONVENTION_CUSTOM,
CALLING_CONVENTION_COUNT,
} CallingConvention;
static_assert(array_length(calling_conventions) == CALLING_CONVENTION_COUNT, "");
typedef enum GlobalSymbolAttribute
{
GLOBAL_SYMBOL_ATTRIBUTE_EXPORT,
GLOBAL_SYMBOL_ATTRIBUTE_EXTERN,
GLOBAL_SYMBOL_ATTRIBUTE_COUNT,
} GlobalSymbolAttribute;
global String global_symbol_attributes[] =
{
strlit("export"),
strlit("extern"),
};
struct GlobalSymbolAttributes
{
u8 exported: 1;
u8 external: 1;
};
typedef struct GlobalSymbolAttributes GlobalSymbolAttributes;
static_assert(array_length(global_symbol_attributes) == GLOBAL_SYMBOL_ATTRIBUTE_COUNT, "");
struct Analyzer
{
Function* function;
};
fn SemaType* analyze_type(Parser* parser, Unit* unit, String src)
{
u64 start_index = parser->i;
u8 start_ch = src.pointer[start_index];
u32 array_start = start_ch == array_expression_start;
u32 u_start = start_ch == 'u';
u32 s_start = start_ch == 's';
u32 float_start = start_ch == 'f';
u32 void_start = start_ch == 'v';
u32 pointer_start = start_ch == pointer_sign;
u32 integer_start = u_start | s_start;
u32 number_start = integer_start | float_start;
if (void_start)
{
trap();
}
else if (array_start)
{
trap();
}
else if (pointer_start)
{
trap();
}
else if (number_start)
{
u64 expected_digit_start = start_index + 1;
u64 i = expected_digit_start;
u32 decimal_digit_count = 0;
u64 top = i + 5;
while (i < top)
{
u8 ch = src.pointer[i];
u32 is_digit = is_decimal_digit(ch);
decimal_digit_count += is_digit;
if (!is_digit)
{
u32 is_alpha = is_alphabetic(ch);
if (is_alpha)
{
decimal_digit_count = 0;
}
break;
}
i += 1;
}
if (decimal_digit_count)
{
parser->i += 1;
if (integer_start)
{
u64 signedness = s_start;
u64 bit_size;
u64 current_i = parser->i;
assert(src.pointer[current_i] >= '0' & src.pointer[current_i] <= '9');
switch (decimal_digit_count) {
case 0:
fail();
case 1:
bit_size = src.pointer[current_i] - '0';
break;
case 2:
bit_size = (src.pointer[current_i] - '0') * 10 + (src.pointer[current_i + 1] - '0');
break;
default:
fail();
}
parser->i += decimal_digit_count;
assert(!is_decimal_digit(src.pointer[parser->i]));
if (bit_size)
{
auto* result = unit->get_integer_type(bit_size, signedness);
return result;
}
else
{
fail();
}
}
else if (float_start)
{
trap();
}
else
{
trap();
}
}
else
{
fail();
}
}
trap();
}
fn u64 parse_hex(String string)
{
u64 value = 0;
for (u8 ch : string)
{
u8 byte;
auto is_decimal = (ch >= '0') & (ch <= '9');
auto is_lower_hex = (ch >= 'a') & (ch <= 'f');
auto is_upper_hex = (ch >= 'A') & (ch <= 'F');
if (is_decimal)
{
byte = ch - '0';
}
else if (is_lower_hex)
{
byte = ch - 'a' + 10;
}
else if (is_upper_hex)
{
byte = ch - 'A' + 10;
}
else
{
fail();
}
value = (value << 4) | (byte & 0x0f);
}
return value;
}
[[nodiscard]] fn Node* parse_constant_integer(Parser* parser, Unit* unit, String src, SemaType* type)
{
auto starting_ch = src[parser->i];
if (starting_ch == '0')
{
auto follow_up_character = src[parser->i + 1];
auto is_hex_start = follow_up_character == 'x';
auto is_octal_start = follow_up_character == 'o';
auto is_bin_start = follow_up_character == 'b';
auto is_prefixed_start = is_hex_start | is_octal_start | is_bin_start;
auto follow_up_alpha = is_alphabetic(follow_up_character);
auto follow_up_digit = is_decimal_digit(follow_up_character);
auto is_valid_after_zero = is_space(follow_up_character, get_next_ch_safe(src, follow_up_character)) | (!follow_up_digit and !follow_up_alpha);
if (is_prefixed_start) {
enum class IntegerPrefix {
hexadecimal,
octal,
binary,
};
IntegerPrefix prefix;
switch (follow_up_character) {
case 'x': prefix = IntegerPrefix::hexadecimal; break;
case 'o': prefix = IntegerPrefix::octal; break;
case 'b': prefix = IntegerPrefix::binary; break;
default: fail();
};
parser->i += 2;
auto start = parser->i;
switch (prefix) {
case IntegerPrefix::hexadecimal:
{
while (is_hex_digit(src[parser->i])) {
parser->i += 1;
}
auto slice = src.slice(start, parser->i);
auto number = parse_hex(slice);
auto* constant_int = Node::add(unit);
constant_int->id = Node::Id::CONSTANT_INT;
constant_int->data_type = { .id = NodeDataType::Id::INTEGER, .bit_count = type->get_bit_count() };
constant_int->constant_int = number;
// TODO: is this fine?
constant_int->reallocate_edges(unit, 1);
return constant_int;
}
case IntegerPrefix::octal:
trap();
case IntegerPrefix::binary:
trap();
}
} else if (is_valid_after_zero) {
parser->i += 1;
auto* constant_int = Node::add(unit);
constant_int->id = Node::Id::CONSTANT_INT;
constant_int->data_type = { .id = NodeDataType::Id::INTEGER, .bit_count = type->get_bit_count() };
constant_int->reallocate_edges(unit, 1);
constant_int->constant_int = 0;
return constant_int;
} else {
fail();
}
trap();
}
else
{
trap();
}
}
[[nodiscard]] fn Node* analyze_single_expression(Analyzer* analyzer, Parser* parser, Unit* unit, String src, SemaType* type, Side side)
{
unused(side);
enum class Unary
{
NONE,
ONE_COMPLEMENT,
NEGATION,
};
auto unary_operation = Unary::NONE;
auto original_starting_ch_index = parser->i;
u8 original_starting_ch = src[original_starting_ch_index];
switch (src[parser->i])
{
case '\'':
trap();
case '"':
trap();
case '-':
trap();
case '~':
trap();
case '#':
trap();
case composite_initialization_start:
trap();
case array_expression_start:
trap();
default:
assert(is_decimal_digit(original_starting_ch) | is_identifier_start(original_starting_ch));
break;
}
auto starting_ch_index = parser->i;
u8 starting_ch = src[starting_ch_index];
auto is_digit = is_decimal_digit(starting_ch);
auto is_identifier = is_identifier_start(starting_ch);
// auto line = get_line(parser);
// auto column = get_column(parser);
if (is_digit)
{
SemaType* integer_type;
if (type)
{
integer_type = type;
}
else
{
switch (unary_operation)
{
case Unary::NONE:
integer_type = unit->get_integer_type(64, 0);
break;
case Unary::ONE_COMPLEMENT:
fail();
case Unary::NEGATION:
fail();
}
}
if (integer_type->id != SemaTypeId::INTEGER)
{
fail();
}
Node* constant_int = parse_constant_integer(parser, unit, src, integer_type);
constant_int->gvn = analyzer->function->node_count;
analyzer->function->node_count += 1;
return constant_int;
}
else if (is_identifier)
{
trap();
}
else
{
fail();
}
}
[[nodiscard]] fn Node* analyze_expression(Analyzer* analyzer, Parser* parser, Unit* unit, String src, SemaType* type, Side side)
{
enum class CurrentOperation
{
NONE,
};
u64 iterations = 0;
SemaType* iteration_type = type;
auto current_operation = CurrentOperation::NONE;
Node* previous_node = 0;
while (1)
{
if ((iterations == 0) & !iteration_type)
{
trap();
}
// u32 line = get_line(parser);
// u32 column = get_column(parser);
Node* current_node;
if (src[parser->i] == '(')
{
trap();
}
else
{
current_node = analyze_single_expression(analyzer, parser, unit, src, iteration_type, side);
}
skip_space(parser, src);
switch (current_operation)
{
case CurrentOperation::NONE:
previous_node = current_node;
break;
}
auto original_index = parser->i;
u8 original = src[original_index];
switch (original)
{
case end_of_statement:
case end_of_argument:
case parenthesis_close:
case bracket_close:
return previous_node;
default:
trap();
}
iterations += 1;
}
}
fn void analyze_local_block(Analyzer* analyzer, Parser* parser, Unit* unit, String src)
{
expect_character(parser, src, block_start);
while (1)
{
skip_space(parser, src);
if (src[parser->i] == block_end)
{
break;
}
auto statement_start_index = parser->i;
u8 statement_start_ch = src[statement_start_index];
if (is_identifier_start(statement_start_ch))
{
String identifier = parse_identifier(parser, src);
if (identifier.equal(strlit("return")))
{
skip_space(parser, src);
auto* return_value = analyze_expression(analyzer, parser, unit, src, analyzer->function->prototype.original_return_type, Side::right);
expect_character(parser, src, ';');
Function* function = analyzer->function;
Node* ret_node = Node::add_from_function(unit, function);
ret_node->id = Node::Id::RETURN;
ret_node->data_type = { .id = NodeDataType::Id::CONTROL };
ret_node->reallocate_edges(unit, 4);
ret_node->input_count = 2;
ret_node->set_input(unit, function, function->root_node, 0);
ret_node->set_input(unit, function, return_value, 1);
}
else
{
trap();
}
}
else
{
trap();
}
}
expect_character(parser, src, block_end);
}
typedef enum SystemVClass
{
SYSTEMV_CLASS_NONE,
SYSTEMV_CLASS_MEMORY,
SYSTEMV_CLASS_INTEGER,
SYSTEMV_CLASS_SSE,
SYSTEMV_CLASS_SSEUP,
} SystemVClass;
struct SystemVClassification
{
SystemVClass v[2];
};
typedef struct SystemVClassification SystemVClassification;
struct SystemVRegisterCount
{
u32 gp_registers;
u32 sse_registers;
};
typedef struct SystemVRegisterCount SystemVRegisterCount;
fn SystemVClassification systemv_classify(SemaType* type, u64 base_offset)
{
SystemVClassification result;
u32 is_memory = base_offset >= 8;
u32 current_index = is_memory;
result.v[current_index] = SYSTEMV_CLASS_MEMORY;
result.v[!current_index] = SYSTEMV_CLASS_NONE;
switch (type->id)
{
case SemaTypeId::VOID:
trap();
case SemaTypeId::NORETURN:
trap();
case SemaTypeId::POINTER:
trap();
case SemaTypeId::INTEGER:
{
u8 bit_count = type->get_bit_count();
switch (bit_count)
{
case 8: case 16: case 32: case 64:
result.v[current_index] = SYSTEMV_CLASS_INTEGER;
break;
default:
trap();
}
} break;
case SemaTypeId::COUNT:
trap();
default:
trap();
}
return result;
}
fn u8 contains_no_user_data(SemaType* type, u64 start, u64 end)
{
unused(end);
if (type->size <= start)
{
return 1;
}
switch (type->id)
{
case SemaTypeId::ARRAY:
trap();
case SemaTypeId::STRUCT:
trap();
case SemaTypeId::UNION:
trap();
default:
return 0;
case SemaTypeId::COUNT:
trap();
}
}
fn SemaType* systemv_get_int_type_at_offset(SemaType* type, u64 offset, SemaType* source_type, u64 source_offset)
{
unused(source_type);
switch (type->id)
{
case SemaTypeId::VOID:
trap();
case SemaTypeId::NORETURN:
trap();
case SemaTypeId::POINTER:
trap();
case SemaTypeId::INTEGER:
{
u8 bit_count = type->get_bit_count();
switch (bit_count)
{
case 8: case 16: case 32: case 64:
if (offset == 0)
{
u64 start = source_offset + type->size;
u64 end = source_offset + 8;
if (contains_no_user_data(type, start, end))
{
return type;
}
trap();
}
else
{
trap();
}
default:
trap();
}
trap();
} break;
case SemaTypeId::COUNT:
trap();
case SemaTypeId::ARRAY:
trap();
case SemaTypeId::STRUCT:
trap();
case SemaTypeId::UNION:
trap();
}
}
fn void analyze_function(Parser* parser, Unit* unit, String src)
{
expect_character(parser, src, 'f');
expect_character(parser, src, 'n');
skip_space(parser, src);
u64 has_function_attributes = src.pointer[parser->i] == function_attribute_start;
parser->i += has_function_attributes;
CallingConvention calling_convention = CALLING_CONVENTION_CUSTOM;
if (has_function_attributes)
{
u64 mask = 0;
while (1)
{
skip_space(parser, src);
if (src.pointer[parser->i] == function_attribute_end)
{
break;
}
String attribute_candidate = parse_identifier(parser, src);
u64 attribute_i;
for (attribute_i = 0; attribute_i < array_length(function_attributes); attribute_i += 1)
{
String function_attribute_string = function_attributes[attribute_i];
if (attribute_candidate.equal(function_attribute_string))
{
if (mask & (1 << attribute_i))
{
fail();
}
auto function_attribute = static_cast<FunctionAttribute>(attribute_i);
mask |= (1 << attribute_i);
switch (function_attribute)
{
case FUNCTION_ATTRIBUTE_CC:
{
skip_space(parser, src);
expect_character(parser, src, '(');
skip_space(parser, src);
expect_character(parser, src, '.');
String candidate_cc = parse_identifier(parser, src);
skip_space(parser, src);
expect_character(parser, src, ')');
u64 cc_i;
for (cc_i = 0; cc_i < array_length(calling_conventions); cc_i += 1)
{
String calling_convention_string = calling_conventions[cc_i];
if (calling_convention_string.equal(candidate_cc))
{
calling_convention = static_cast<CallingConvention>(cc_i);
break;
}
}
if (cc_i == array_length(calling_conventions))
{
fail();
}
} break;
default:
trap();
}
break;
}
}
if (attribute_i == array_length(function_attributes))
{
fail();
}
skip_space(parser, src);
u8 after_ch = src.pointer[parser->i];
switch (after_ch)
{
case function_attribute_end: break;
default: fail();
}
}
expect_character(parser, src, function_attribute_end);
skip_space(parser, src);
}
Hash name_hash = parse_and_intern_identifier(parser, unit, src);
skip_space(parser, src);
u64 has_global_attributes = src.pointer[parser->i] == symbol_attribute_start;
parser->i += has_global_attributes;
GlobalSymbolAttributes symbol_attributes = {};
if (has_global_attributes)
{
u64 mask = 0;
while (1)
{
skip_space(parser, src);
if (src.pointer[parser->i] == symbol_attribute_end)
{
break;
}
String candidate_attribute = parse_identifier(parser, src);
skip_space(parser, src);
switch (src.pointer[parser->i])
{
case symbol_attribute_end:
break;
case ',':
parser->i += 1;
break;
default:
fail();
}
u64 attribute_i;
for (attribute_i = 0; attribute_i < array_length(global_symbol_attributes); attribute_i += 1)
{
String attribute_string = global_symbol_attributes[attribute_i];
if (attribute_string.equal(candidate_attribute))
{
if (mask & (1 << attribute_i))
{
fail();
}
mask |= 1 << attribute_i;
auto attribute = static_cast<GlobalSymbolAttribute>(attribute_i);
switch (attribute)
{
case GLOBAL_SYMBOL_ATTRIBUTE_EXPORT:
symbol_attributes.exported = 1;
break;
case GLOBAL_SYMBOL_ATTRIBUTE_EXTERN:
symbol_attributes.external = 1;
break;
default:
trap();
}
break;
}
}
if (attribute_i == array_length(global_symbol_attributes))
{
fail();
}
}
expect_character(parser, src, symbol_attribute_end);
skip_space(parser, src);
}
if (symbol_attributes.exported & symbol_attributes.external)
{
fail();
}
expect_character(parser, src, function_argument_start);
while (1)
{
skip_space(parser, src);
if (src.pointer[parser->i] == function_argument_end)
{
break;
}
// TODO: function arguments in function definition
trap();
}
expect_character(parser, src, function_argument_end);
skip_space(parser, src);
PinnedArray<SemaType*> original_argument_types = {};
SemaType* original_return_type = analyze_type(parser, unit, src);
skip_space(parser, src);
switch (calling_convention)
{
case CALLING_CONVENTION_C:
{
// First process the return type ABI
AbiInfo return_type_abi = {};
{
SystemVClassification return_type_classes = systemv_classify(original_return_type, 0);
assert(return_type_classes.v[1] != SYSTEMV_CLASS_MEMORY | return_type_classes.v[0] == SYSTEMV_CLASS_MEMORY);
assert(return_type_classes.v[1] != SYSTEMV_CLASS_SSEUP | return_type_classes.v[0] == SYSTEMV_CLASS_SSE);
SemaType* low_part = 0;
switch (return_type_classes.v[0])
{
case SYSTEMV_CLASS_INTEGER:
{
SemaType* result_type = systemv_get_int_type_at_offset(original_return_type, 0, original_return_type, 0);
if (return_type_classes.v[1] == SYSTEMV_CLASS_NONE & original_return_type->get_bit_count() < 32)
{
trap();
}
low_part = result_type;
} break;
default:
trap();
}
assert(low_part);
SemaType* high_part = 0;
switch (return_type_classes.v[1])
{
case SYSTEMV_CLASS_NONE:
break;
case SYSTEMV_CLASS_MEMORY:
trap();
case SYSTEMV_CLASS_INTEGER:
trap();
case SYSTEMV_CLASS_SSE:
trap();
case SYSTEMV_CLASS_SSEUP:
trap();
}
if (high_part)
{
trap();
}
else
{
// TODO:
u8 is_type = 1;
if (is_type)
{
if (low_part == original_return_type)
{
return_type_abi =
{
.kind = ABI_INFO_DIRECT,
};
}
else
{
trap();
}
}
else
{
trap();
}
}
}
// Now process the ABI for argument types
PinnedArray<AbiInfo> argument_type_abis = {};
// u32 abi_argument_type_count = 0;
{
SystemVRegisterCount available_registers = {
.gp_registers = 6,
.sse_registers = 8,
};
available_registers.gp_registers -= return_type_abi.kind == ABI_INFO_INDIRECT;
// TODO: return by reference
u8 return_by_reference = 0;
if (return_by_reference)
{
trap();
}
for (u32 original_argument_index = 0; original_argument_index < original_argument_types.length; original_argument_index += 1)
{
trap();
}
}
switch (return_type_abi.kind)
{
case ABI_INFO_IGNORE: case ABI_INFO_DIRECT:
break;
case ABI_INFO_DIRECT_PAIR:
trap();
case ABI_INFO_DIRECT_COERCE:
trap();
case ABI_INFO_DIRECT_COERCE_INT:
trap();
case ABI_INFO_DIRECT_SPLIT_STRUCT_I32:
trap();
case ABI_INFO_EXPAND_COERCE:
trap();
case ABI_INFO_INDIRECT:
trap();
case ABI_INFO_EXPAND:
trap();
}
// assert(abi_argument_type_count == 0);
// TODO: reserve memory for them
// Slice<Node::DataType> abi_argument_types = {};
for (u32 i = 0; i < argument_type_abis.length; i += 1)
{
trap();
}
auto* function = unit->functions.add_one();
*function = {
.symbol = {
.name = name_hash,
.id = Symbol::Id::function,
.linkage = symbol_attributes.external ? Symbol::Linkage::external : Symbol::Linkage::internal,
},
.root_node = 0,
.parameters = unit->arena->allocate_many<Node*>(argument_type_abis.length),
.prototype = {
.argument_type_abis = argument_type_abis.pointer,
.original_argument_types = original_argument_types.pointer,
.original_return_type = original_return_type,
.return_type_abi = return_type_abi,
.original_argument_count = original_argument_types.length,
.varags = 0,
},
.node_count = 0,
.parameter_count = (u16)argument_type_abis.length,
};
Node* root_node = Node::add_from_function(unit, function);
root_node->id = Node::Id::ROOT;
root_node->data_type = {
.id = NodeDataType::Id::TUPLE,
};
root_node->reallocate_edges(unit, 4);
// TODO: revisit
// auto* control_node = root_node->project(unit, function, {
// .type = { .id = NodeDataType::Id::CONTROL },
// });
// auto* memory_node = root_node->project(unit, function, {});
// auto* pointer_node = root_node->project(unit, function, {});
// function->parameters[0] = control_node;
// function->parameters[1] = memory_node;
// function->parameters[2] = pointer_node;
for (u32 argument_i = 0; argument_i < argument_type_abis.length; argument_i += 1)
{
trap();
}
// TODO: callgraph
// TODO: revisit
// Node* ret_node = Node::add_from_function(unit, function);
// ret_node->id = Node::Id::RETURN;
// ret_node->data_type = { .id = NodeDataType::Id::CONTROL };
// ret_node->reallocate_edges(unit, 4);
// ret_node->input_count = 2;
// ret_node->set_input(unit, function, root_node, 0);
switch (symbol_attributes.external)
{
case 0:
{
Analyzer analyzer = {};
analyzer.function = function;
analyze_local_block(&analyzer, parser, unit, src);
} break;
case 1:
trap();
}
} break;
case CALLING_CONVENTION_CUSTOM:
trap();
break;
case CALLING_CONVENTION_COUNT:
trap();
break;
}
}
fn void unit_file_analyze(Unit* unit, File* file)
{
unit_file_read(unit, file);
Parser parser = {};
String src = file->source_code;
while (1)
{
skip_space(&parser, src);
if (parser.i >= src.length)
{
break;
}
// u32 line = get_line(&parser);
// u32 column = get_column(&parser);
u64 declaration_start_index = parser.i;
u8 declaration_start_ch = src.pointer[declaration_start_index];
switch (declaration_start_ch)
{
case '>':
trap();
break;
case 'f':
if (get_next_ch_safe(src, declaration_start_index) == 'n')
{
analyze_function(&parser, unit, src);
}
else
{
fail();
}
break;
default:
fail();
}
}
}
global Instance instance;
extern "C" void entry_point()
{
instance.arena = Arena::init(Arena::default_size, Arena::minimum_granularity, KB(4));
Unit* unit = instance_add_unit(&instance);
File* file = unit_add_file(unit, strlit("tests/first/main.nat"));
unit_initialize(unit);
unit_file_analyze(unit, file);
}