Kernel: Cleanup accessing userspace memory

Instead of doing page validiation and loading manually we just do simple
memcpy and handle the possible page faults

.clangd

@@ -0,0 +1,13 @@
+Diagnostics:
+  Suppress: target_unsupported_type
+
+CompileFlags:
+  Remove: [
+    -fstrict-volatile-bitfields,
+    -fno-tree-loop-distribute-patterns
+  ]
+  Add: [
+    -D__banan_os__,
+    -D__arch__=x86_64,
+    -D__x86_64__
+  ]

.gitignore

@@ -3,3 +3,4 @@
 build/
 base/
 script/fakeroot-context
+tools/update-image-perms

.vscode/c_cpp_properties.json

@@ -0,0 +1,38 @@
+{
+    "configurations": [
+        {
+            "name": "banan-os",
+            "includePath": [
+                "${workspaceFolder}/BAN/include",
+                "${workspaceFolder}/kernel/include",
+                "${workspaceFolder}/userspace/libraries/*/include"
+            ],
+            "defines": [
+                "__arch=x86_64",
+                "__enable_sse=1"
+            ],
+            "compilerPath": "${workspaceFolder}/toolchain/local/bin/x86_64-banan_os-gcc",
+            "cStandard": "c17",
+            "cppStandard": "gnu++20",
+            "intelliSenseMode": "linux-gcc-x64"
+        },
+        {
+            "name": "banan-os-kernel",
+            "includePath": [
+                "${workspaceFolder}/BAN/include",
+                "${workspaceFolder}/kernel/include",
+                "${workspaceFolder}/userspace/libraries/*/include"
+            ],
+            "defines": [
+                "__arch=x86_64",
+                "__is_kernel",
+                "__enable_sse=1"
+            ],
+            "compilerPath": "${workspaceFolder}/toolchain/local/bin/x86_64-banan_os-gcc",
+            "cStandard": "c17",
+            "cppStandard": "gnu++20",
+            "intelliSenseMode": "linux-gcc-x64"
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "cmake.configureOnOpen": false,
+    "editor.tabSize": 4,
+    "editor.insertSpaces": false,
+    "editor.detectIndentation": false,
+    "clangd.arguments": [
+        "--compile-commands-dir=${workspaceFolder}/build",
+        "-header-insertion=never"
+    ]
+}

BAN/CMakeLists.txt

@@ -1,7 +1,3 @@
-cmake_minimum_required(VERSION 3.26)
-
-project(BAN CXX)
-
 set(BAN_SOURCES
 	BAN/Assert.cpp
 	BAN/New.cpp
@@ -9,16 +5,14 @@ set(BAN_SOURCES
 	BAN/Time.cpp
 )
 
-add_custom_target(ban-headers
-	COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/include/ ${BANAN_INCLUDE}/
-	DEPENDS sysroot
-)
-
 add_library(ban ${BAN_SOURCES})
-add_dependencies(ban headers libc-install)
+target_link_options(ban PRIVATE -nolibc)
+banan_link_library(ban libc)
 
-add_custom_target(ban-install
-	COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_BINARY_DIR}/libban.a ${BANAN_LIB}/
-	DEPENDS ban
-	BYPRODUCTS ${BANAN_LIB}/libban.a
-)
+set_target_properties(ban PROPERTIES OUTPUT_NAME libban)
+
+# set SONAME as cmake doesn't set it for some reason??
+set_target_properties(ban PROPERTIES LINK_FLAGS "-Wl,-soname,libban.so")
+
+banan_install_headers(ban)
+install(TARGETS ban OPTIONAL)

BAN/include/BAN/Array.h

@@ -18,78 +18,78 @@ namespace BAN
 		using const_iterator = ConstIteratorSimple<T, Array>;
 
 	public:
-		Array() = default;
-		Array(const T&);
+		constexpr Array() = default;
+		constexpr Array(const T&);
 
 		iterator begin() { return iterator(m_data); }
 		iterator end() { return iterator(m_data + size()); }
 		const_iterator begin() const { return const_iterator(m_data); }
 		const_iterator end() const { return const_iterator(m_data + size()); }
 
-		const T& operator[](size_type) const;
-		T& operator[](size_type);
+		constexpr const T& operator[](size_type) const;
+		constexpr T& operator[](size_type);
 
-		const T& back() const;
-		T& back();
-		const T& front() const;
-		T& front();
+		constexpr const T& back() const;
+		constexpr T& back();
+		constexpr const T& front() const;
+		constexpr T& front();
 
 		Span<T> span() { return Span(m_data, size()); }
-		const Span<T> span() const { return Span(m_data, size()); }
+		Span<const T> span() const { return Span(m_data, size()); }
 
 		constexpr size_type size() const;
 
-		const T* data() const { return m_data; }
-		T* data() { return m_data; }
+		constexpr const T* data() const { return m_data; }
+		constexpr T* data() { return m_data; }
 
 	private:
 		T m_data[S] {};
 	};
 
 	template<typename T, size_t S>
-	Array<T, S>::Array(const T& value)
+	constexpr Array<T, S>::Array(const T& value)
 	{
 		for (size_type i = 0; i < S; i++)
 			m_data[i] = value;
 	}
 
 	template<typename T, size_t S>
-	const T& Array<T, S>::operator[](size_type index) const
+	constexpr const T& Array<T, S>::operator[](size_type index) const
 	{
 		ASSERT(index < S);
 		return m_data[index];
 	}
 
 	template<typename T, size_t S>
-	T& Array<T, S>::operator[](size_type index)
+	constexpr T& Array<T, S>::operator[](size_type index)
 	{
 		ASSERT(index < S);
 		return m_data[index];
 	}
 
 	template<typename T, size_t S>
-	const T& Array<T, S>::back() const
+	constexpr const T& Array<T, S>::back() const
 	{
 		ASSERT(S != 0);
 		return m_data[S - 1];
 	}
 
 	template<typename T, size_t S>
-	T& Array<T, S>::back()
+	constexpr T& Array<T, S>::back()
 	{
 		ASSERT(S != 0);
 		return m_data[S - 1];
 	}
 
 	template<typename T, size_t S>
-	const T& Array<T, S>::front() const
+	constexpr const T& Array<T, S>::front() const
 	{
 		ASSERT(S != 0);
 		return m_data[0];
 	}
 
 	template<typename T, size_t S>
-	T& Array<T, S>::front()
+	constexpr T& Array<T, S>::front()
 	{
 		ASSERT(S != 0);
 		return m_data[0];

BAN/include/BAN/Atomic.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <BAN/Traits.h>
+
 namespace BAN
 {
 
@@ -13,8 +15,36 @@ namespace BAN
 		memory_order_seq_cst = __ATOMIC_SEQ_CST,
 	};
 
-	template<typename T, MemoryOrder MEM_ORDER = MemoryOrder::memory_order_seq_cst>
-	requires requires { __atomic_always_lock_free(sizeof(T), 0); }
+	template<typename T> concept atomic_c = is_integral_v<T> || is_pointer_v<T>;
+	template<typename T> concept atomic_lockfree_c = (is_integral_v<T> || is_pointer_v<T>) && __atomic_always_lock_free(sizeof(T), 0);
+
+	template<atomic_lockfree_c T, atomic_c U>
+	inline void atomic_store(T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { __atomic_store_n(&obj, value, mem_order); }
+	template<atomic_lockfree_c T>
+	inline T atomic_load(T& obj, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_load_n(&obj, mem_order); }
+
+	template<atomic_lockfree_c T, atomic_c U>
+	inline T atomic_exchange(T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_exchange_n(&obj, value, mem_order); }
+	template<atomic_lockfree_c T, atomic_lockfree_c U, atomic_c V>
+	inline bool atomic_compare_exchange(T& obj, U& expected, V value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_compare_exchange_n(&obj, &expected, value, false, mem_order, mem_order); }
+
+#define DECL_ATOMIC_INLINE template<atomic_lockfree_c T, atomic_c U> inline
+	DECL_ATOMIC_INLINE T atomic_add_fetch (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_add_fetch (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_sub_fetch (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_sub_fetch (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_and_fetch (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_and_fetch (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_xor_fetch (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_xor_fetch (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_or_fetch  (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_or_fetch  (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_nand_fetch(T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_nand_fetch(&obj, value, mem_order); }
+
+	DECL_ATOMIC_INLINE T atomic_fetch_add (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_add (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_fetch_sub (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_sub (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_fetch_and (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_and (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_fetch_xor (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_xor (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_fetch_or  (T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_or  (&obj, value, mem_order); }
+	DECL_ATOMIC_INLINE T atomic_fetch_nand(T& obj, U value, MemoryOrder mem_order = MemoryOrder::memory_order_seq_cst) { return __atomic_fetch_nand(&obj, value, mem_order); }
+#undef DECL_ATOMIC_INLINE
+
+	template<atomic_lockfree_c T, MemoryOrder MEM_ORDER = MemoryOrder::memory_order_seq_cst>
 	class Atomic
 	{
 		Atomic(const Atomic&) = delete;
@@ -26,26 +56,41 @@ namespace BAN
 		constexpr Atomic() : m_value(0) {}
 		constexpr Atomic(T val) : m_value(val) {}
 
-		inline T load(MemoryOrder mem_order = MEM_ORDER) const volatile			{ return __atomic_load_n(&m_value, mem_order); }
-		inline void store(T val, MemoryOrder mem_order = MEM_ORDER) volatile	{ __atomic_store_n(&m_value, val, mem_order); }
+		inline T load(MemoryOrder mem_order = MEM_ORDER) const volatile			{ return atomic_load(m_value, mem_order); }
+		inline void store(T val, MemoryOrder mem_order = MEM_ORDER) volatile	{ atomic_store(m_value, val, mem_order); }
 
 		inline T operator=(T val) volatile { store(val); return val; }
 
 		inline operator T() const volatile { return load(); }
 
-		inline T operator+=(T val) volatile { return __atomic_add_fetch(&m_value, val, MEM_ORDER); }
-		inline T operator-=(T val) volatile { return __atomic_sub_fetch(&m_value, val, MEM_ORDER); }
-		inline T operator&=(T val) volatile { return __atomic_and_fetch(&m_value, val, MEM_ORDER); }
-		inline T operator^=(T val) volatile { return __atomic_xor_fetch(&m_value, val, MEM_ORDER); }
-		inline T operator|=(T val) volatile { return __atomic_or_fetch(&m_value, val, MEM_ORDER); }
+		inline T operator+=(T val) volatile { return atomic_add_fetch(m_value, val, MEM_ORDER); }
+		inline T operator-=(T val) volatile { return atomic_sub_fetch(m_value, val, MEM_ORDER); }
+		inline T operator&=(T val) volatile { return atomic_and_fetch(m_value, val, MEM_ORDER); }
+		inline T operator^=(T val) volatile { return atomic_xor_fetch(m_value, val, MEM_ORDER); }
+		inline T operator|=(T val) volatile { return atomic_or_fetch(m_value, val, MEM_ORDER); }
 
-		inline T operator--() volatile { return __atomic_sub_fetch(&m_value, 1, MEM_ORDER); }
-		inline T operator++() volatile { return __atomic_add_fetch(&m_value, 1, MEM_ORDER); }
+		inline T operator--() volatile { return atomic_sub_fetch(m_value, 1, MEM_ORDER); }
+		inline T operator++() volatile { return atomic_add_fetch(m_value, 1, MEM_ORDER); }
 
-		inline T operator--(int) volatile { return __atomic_fetch_sub(&m_value, 1, MEM_ORDER); }
-		inline T operator++(int) volatile { return __atomic_fetch_add(&m_value, 1, MEM_ORDER); }
+		inline T operator--(int) volatile { return atomic_fetch_sub(m_value, 1, MEM_ORDER); }
+		inline T operator++(int) volatile { return atomic_fetch_add(m_value, 1, MEM_ORDER); }
 
-		inline bool compare_exchange(T expected, T desired, MemoryOrder mem_order = MEM_ORDER) volatile { return __atomic_compare_exchange_n(&m_value, &expected, desired, false, mem_order, mem_order); }
+		inline bool compare_exchange(T& expected, T desired, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_compare_exchange(m_value, expected, desired, mem_order); }
+		inline T exchange(T desired, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_exchange(m_value, desired, mem_order); };
+
+		inline T add_fetch (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_add_fetch (m_value, val, mem_order); }
+		inline T sub_fetch (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_sub_fetch (m_value, val, mem_order); }
+		inline T and_fetch (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_and_fetch (m_value, val, mem_order); }
+		inline T xor_fetch (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_xor_fetch (m_value, val, mem_order); }
+		inline T or_fetch  (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_or_fetch  (m_value, val, mem_order); }
+		inline T nand_fetch(T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_nand_fetch(m_value, val, mem_order); }
+
+		inline T fetch_add (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_add (m_value, val, mem_order); }
+		inline T fetch_sub (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_sub (m_value, val, mem_order); }
+		inline T fetch_and (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_and (m_value, val, mem_order); }
+		inline T fetch_xor (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_xor (m_value, val, mem_order); }
+		inline T fetch_or  (T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_or  (m_value, val, mem_order); }
+		inline T fetch_nand(T val, MemoryOrder mem_order = MEM_ORDER) volatile { return atomic_fetch_nand(m_value, val, mem_order); }
 
 	private:
 		T m_value;

BAN/include/BAN/ByteSpan.h

@@ -21,60 +21,56 @@ namespace BAN
 			, m_size(size)
 		{ }
 
-		ByteSpanGeneral(ByteSpanGeneral& other)
+		template<bool SRC_CONST>
+		ByteSpanGeneral(const ByteSpanGeneral<SRC_CONST>& other) requires(CONST || !SRC_CONST)
 			: m_data(other.data())
 			, m_size(other.size())
 		{ }
-		template<bool C2>
-		ByteSpanGeneral(const ByteSpanGeneral<C2>& other) requires(CONST)
+		template<bool SRC_CONST>
+		ByteSpanGeneral(ByteSpanGeneral<SRC_CONST>&& other) requires(CONST || !SRC_CONST)
 			: m_data(other.data())
 			, m_size(other.size())
-		{ }
-		ByteSpanGeneral(Span<uint8_t> other)
-			: m_data(other.data())
-			, m_size(other.size())
-		{ }
-		ByteSpanGeneral(const Span<const uint8_t>& other) requires(CONST)
-			: m_data(other.data())
-			, m_size(other.size())
-		{ }
+		{
+			other.clear();
+		}
 
-		ByteSpanGeneral& operator=(ByteSpanGeneral other)
+		template<typename T>
+		ByteSpanGeneral(const Span<T>& other) requires(is_same_v<T, uint8_t> || (is_same_v<T, const uint8_t> && CONST))
+			: m_data(other.data())
+			, m_size(other.size())
+		{ }
+		template<typename T>
+		ByteSpanGeneral(Span<T>&& other) requires(is_same_v<T, uint8_t> || (is_same_v<T, const uint8_t> && CONST))
+			: m_data(other.data())
+			, m_size(other.size())
+		{
+			other.clear();
+		}
+
+		template<bool SRC_CONST>
+		ByteSpanGeneral& operator=(const ByteSpanGeneral<SRC_CONST>& other) requires(CONST || !SRC_CONST)
 		{
 			m_data = other.data();
 			m_size = other.size();
 			return *this;
 		}
-		template<bool C2>
-		ByteSpanGeneral& operator=(const ByteSpanGeneral<C2>& other) requires(CONST)
-		{
-			m_data = other.data();
-			m_size = other.size();
-			return *this;
-		}
-		ByteSpanGeneral& operator=(Span<uint8_t> other)
-		{
-			m_data = other.data();
-			m_size = other.size();
-			return *this;
-		}
-		ByteSpanGeneral& operator=(const Span<const uint8_t>& other) requires(CONST)
+		template<bool SRC_CONST>
+		ByteSpanGeneral& operator=(ByteSpanGeneral<SRC_CONST>&& other) requires(CONST || !SRC_CONST)
 		{
 			m_data = other.data();
 			m_size = other.size();
+			other.clear();
 			return *this;
 		}
 
 		template<typename S>
-		requires(CONST || !is_const_v<S>)
-		static ByteSpanGeneral from(S& value)
+		static ByteSpanGeneral from(S& value) requires(CONST || !is_const_v<S>)
 		{
 			return ByteSpanGeneral(reinterpret_cast<value_type*>(&value), sizeof(S));
 		}
 
 		template<typename S>
-		requires(!CONST && !is_const_v<S>)
-		S& as()
+		S& as() const requires(!CONST || is_const_v<S>)
 		{
 			ASSERT(m_data);
 			ASSERT(m_size >= sizeof(S));
@@ -82,30 +78,13 @@ namespace BAN
 		}
 
 		template<typename S>
-		requires(is_const_v<S>)
-		S& as() const
-		{
-			ASSERT(m_data);
-			ASSERT(m_size >= sizeof(S));
-			return *reinterpret_cast<S*>(m_data);
-		}
-
-		template<typename S>
-		requires(!CONST && !is_const_v<S>)
-		Span<S> as_span()
+		Span<S> as_span() const requires(!CONST || is_const_v<S>)
 		{
 			ASSERT(m_data);
 			return Span<S>(reinterpret_cast<S*>(m_data), m_size / sizeof(S));
 		}
 
-		template<typename S>
-		const Span<S> as_span() const
-		{
-			ASSERT(m_data);
-			return Span<S>(reinterpret_cast<S*>(m_data), m_size / sizeof(S));
-		}
-
-		ByteSpanGeneral slice(size_type offset, size_type length = size_type(-1))
+		[[nodiscard]] ByteSpanGeneral slice(size_type offset, size_type length = size_type(-1)) const
 		{
 			ASSERT(m_data);
 			ASSERT(m_size >= offset);
@@ -115,25 +94,28 @@ namespace BAN
 			return ByteSpanGeneral(m_data + offset, length);
 		}
 
-		value_type& operator[](size_type offset)
-		{
-			ASSERT(offset < m_size);
-			return m_data[offset];
-		}
-		const value_type& operator[](size_type offset) const
+		value_type& operator[](size_type offset) const
 		{
 			ASSERT(offset < m_size);
 			return m_data[offset];
 		}
 
-		value_type* data() { return m_data; }
-		const value_type* data() const { return m_data; }
+		value_type* data() const { return m_data; }
 
+		bool empty() const { return m_size == 0; }
 		size_type size() const { return m_size; }
 
+		void clear()
+		{
+			m_data = nullptr;
+			m_size = 0;
+		}
+
 	private:
 		value_type* m_data { nullptr };
 		size_type m_size { 0 };
+
+		friend class ByteSpanGeneral<!CONST>;
 	};
 
 	using ByteSpan = ByteSpanGeneral<false>;

BAN/include/BAN/CircularQueue.h

@@ -24,13 +24,21 @@ namespace BAN
 		void push(const T&);
 		void push(T&&);
 		template<typename... Args>
-		void emplace(Args&&... args);
+		void emplace(Args&&... args) requires is_constructible_v<T, Args...>;
 
 		void pop();
 
 		const T& front() const;
 		T& front();
 
+		const T& back() const;
+		T& back();
+
+		const T& operator[](size_t index) const;
+		T& operator[](size_t index);
+
+		void clear();
+
 		size_type size() const { return m_size; }
 		bool empty() const { return size() == 0; }
 		bool full() const { return size() == capacity(); }
@@ -50,8 +58,7 @@ namespace BAN
 	template<typename T, size_t S>
 	CircularQueue<T, S>::~CircularQueue()
 	{
-		for (size_type i = 0; i < m_size; i++)
-			element_at((m_first + i) % capacity())->~T();
+		clear();
 	}
 
 	template<typename T, size_t S>
@@ -68,7 +75,7 @@ namespace BAN
 
 	template<typename T, size_t S>
 	template<typename... Args>
-	void CircularQueue<T, S>::emplace(Args&&... args)
+	void CircularQueue<T, S>::emplace(Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		ASSERT(!full());
 		new (element_at(((m_first + m_size) % capacity()))) T(BAN::forward<Args>(args)...);
@@ -98,6 +105,42 @@ namespace BAN
 		return *element_at(m_first);
 	}
 
+	template<typename T, size_t S>
+	const T& CircularQueue<T, S>::back() const
+	{
+		ASSERT(!empty());
+		return *element_at((m_first + m_size - 1) % capacity());
+	}
+
+	template<typename T, size_t S>
+	T& CircularQueue<T, S>::back()
+	{
+		ASSERT(!empty());
+		return *element_at((m_first + m_size - 1) % capacity());
+	}
+
+	template<typename T, size_t S>
+	const T& CircularQueue<T, S>::operator[](size_t index) const
+	{
+		ASSERT(index < m_size);
+		return *element_at((m_first + index) % capacity());
+	}
+
+	template<typename T, size_t S>
+	T& CircularQueue<T, S>::operator[](size_t index)
+	{
+		ASSERT(index < m_size);
+		return *element_at((m_first + index) % capacity());
+	}
+
+	template<typename T, size_t S>
+	void CircularQueue<T, S>::clear()
+	{
+		for (size_type i = 0; i < m_size; i++)
+			element_at((m_first + i) % capacity())->~T();
+		m_size = 0;
+	}
+
 	template<typename T, size_t S>
 	const T* CircularQueue<T, S>::element_at(size_type index) const
 	{

BAN/include/BAN/Debug.h

@@ -9,27 +9,53 @@
 #include <BAN/Formatter.h>
 #include <stdio.h>
 
-#define __debug_putchar [](int c) { putc(c, stddbg); }
+#define __debug_putchar [](int c) { putc_unlocked(c, stddbg); }
 
 #define dprintln(...)											\
 	do {														\
+		flockfile(stddbg);										\
 		BAN::Formatter::print(__debug_putchar, __VA_ARGS__);	\
-		BAN::Formatter::print(__debug_putchar,"\r\n");			\
+		BAN::Formatter::print(__debug_putchar,"\n");			\
 		fflush(stddbg);											\
+		funlockfile(stddbg);									\
 	} while (false)
 
-#define dwarnln(...)										\
-	do {													\
-		BAN::Formatter::print(__debug_putchar, "\e[33m");	\
-		dprintln(__VA_ARGS__);								\
-		BAN::Formatter::print(__debug_putchar, "\e[m");		\
+#define dwarnln(...)											\
+	do {														\
+		flockfile(stddbg);										\
+		BAN::Formatter::print(__debug_putchar, "\e[33m");		\
+		BAN::Formatter::print(__debug_putchar, __VA_ARGS__);	\
+		BAN::Formatter::print(__debug_putchar, "\e[m\n");		\
+		fflush(stddbg);											\
+		funlockfile(stddbg);									\
 	} while(false)
 
-#define derrorln(...)										\
-	do {													\
-		BAN::Formatter::print(__debug_putchar, "\e[31m");	\
-		dprintln(__VA_ARGS__);								\
-		BAN::Formatter::print(__debug_putchar, "\e[m");		\
+#define derrorln(...)											\
+	do {														\
+		flockfile(stddbg);										\
+		BAN::Formatter::print(__debug_putchar, "\e[31m");		\
+		BAN::Formatter::print(__debug_putchar, __VA_ARGS__);	\
+		BAN::Formatter::print(__debug_putchar, "\e[m\n");		\
+		fflush(stddbg);											\
+		funlockfile(stddbg);									\
+	} while(false)
+
+#define dprintln_if(cond, ...)		\
+	do {							\
+		if constexpr(cond)			\
+			dprintln(__VA_ARGS__);	\
+	} while(false)
+
+#define dwarnln_if(cond, ...)		\
+	do {							\
+		if constexpr(cond)			\
+			dwarnln(__VA_ARGS__);	\
+	} while(false)
+
+#define derrorln_if(cond, ...)		\
+	do {							\
+		if constexpr(cond)			\
+			derrorln(__VA_ARGS__);	\
 	} while(false)
 
 #endif

BAN/include/BAN/Endianness.h

@@ -70,15 +70,19 @@ namespace BAN
 	template<integral T>
 	struct LittleEndian
 	{
+		constexpr LittleEndian()
+			: raw(0)
+		{ }
+
 		constexpr LittleEndian(T value)
-		{
-			raw = host_to_little_endian(value);
-		}
+			: raw(host_to_little_endian(value))
+		{ }
 
 		constexpr operator T() const
 		{
 			return host_to_little_endian(raw);
 		}
+
 	private:
 		T raw;
 	};
@@ -86,15 +90,19 @@ namespace BAN
 	template<integral T>
 	struct BigEndian
 	{
+		constexpr BigEndian()
+			: raw(0)
+		{ }
+
 		constexpr BigEndian(T value)
-		{
-			raw = host_to_big_endian(value);
-		}
+			: raw(host_to_big_endian(value))
+		{ }
 
 		constexpr operator T() const
 		{
 			return host_to_big_endian(raw);
 		}
+
 	private:
 		T raw;
 	};
@@ -108,4 +116,10 @@ namespace BAN
 		return host_to_big_endian(value);
 	}
 
+	template<integral T>
+	constexpr T network_endian_to_host(T value)
+	{
+		return big_endian_to_host(value);
+	}
+
 }

BAN/include/BAN/Errors.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <BAN/Formatter.h>
+#include <BAN/NoCopyMove.h>
 #include <BAN/Variant.h>
 
 #include <errno.h>
@@ -9,16 +10,16 @@
 #ifdef __is_kernel
 	#include <kernel/Panic.h>
 	#include <kernel/Errors.h>
-	#define MUST(expr)		 ({ auto&& e = expr; if (e.is_error()) Kernel::panic("{}", e.error()); e.release_value(); })
-	#define MUST_REF(expr)	*({ auto&& e = expr; if (e.is_error()) Kernel::panic("{}", e.error()); &e.release_value(); })
+	#define MUST(...)		 ({ auto&& e = (__VA_ARGS__); if (e.is_error()) Kernel::panic("{}", e.error()); e.release_value(); })
+	#define MUST_REF(...)	*({ auto&& e = (__VA_ARGS__); if (e.is_error()) Kernel::panic("{}", e.error()); &e.release_value(); })
 #else
-	#include <assert.h>
-	#define MUST(expr)		 ({ auto&& e = expr; assert(!e.is_error()); e.release_value(); })
-	#define MUST_REF(expr)	*({ auto&& e = expr; assert(!e.is_error()); &e.release_value(); })
+	#include <BAN/Debug.h>
+	#define MUST(...)		 ({ auto&& e = (__VA_ARGS__); if (e.is_error()) { derrorln("MUST(" #__VA_ARGS__ "): {}", e.error()); __builtin_trap(); } e.release_value(); })
+	#define MUST_REF(...)	*({ auto&& e = (__VA_ARGS__); if (e.is_error()) { derrorln("MUST(" #__VA_ARGS__ "): {}", e.error()); __builtin_trap(); } &e.release_value(); })
 #endif
 
-#define TRY(expr)		 ({ auto&& e = expr; if (e.is_error()) return e.release_error(); e.release_value(); })
-#define TRY_REF(expr)	*({ auto&& e = expr; if (e.is_error()) return e.release_error(); &e.release_value(); })
+#define TRY(...)		 ({ auto&& e = (__VA_ARGS__); if (e.is_error()) return e.release_error(); e.release_value(); })
+#define TRY_REF(...)	*({ auto&& e = (__VA_ARGS__); if (e.is_error()) return e.release_error(); &e.release_value(); })
 
 namespace BAN
 {
@@ -36,7 +37,14 @@ namespace BAN
 		{
 			return Error((uint64_t)error | kernel_error_mask);
 		}
+#else
+		template<size_t N>
+		consteval static Error from_literal(const char (&message)[N])
+		{
+			return Error(message);
+		}
 #endif
+
 		static Error from_errno(int error)
 		{
 			return Error(error);
@@ -54,12 +62,15 @@ namespace BAN
 		}
 #endif
 
-		uint64_t get_error_code() const { return m_error_code; }
+		constexpr uint64_t get_error_code() const { return m_error_code; }
 		const char* get_message() const
 		{
 #ifdef __is_kernel
 			if (m_error_code & kernel_error_mask)
 				return Kernel::error_string(kernel_error());
+#else
+			if (m_message)
+				return m_message;
 #endif
 			if (auto* desc = strerrordesc_np(m_error_code))
 				return desc;
@@ -67,16 +78,27 @@ namespace BAN
 		}
 
 	private:
-		Error(uint64_t error)
+		constexpr Error(uint64_t error)
 			: m_error_code(error)
 		{}
 
-		uint64_t m_error_code;
+#ifndef __is_kernel
+		constexpr Error(const char* message)
+			: m_message(message)
+		{}
+#endif
+
+		uint64_t m_error_code { 0 };
+
+#ifndef __is_kernel
+		const char* m_message { nullptr };
+#endif
 	};
 
 	template<typename T>
 	class [[nodiscard]] ErrorOr
 	{
+		BAN_NON_COPYABLE(ErrorOr);
 	public:
 		ErrorOr(const T& value)
 			: m_data(value)
@@ -90,6 +112,14 @@ namespace BAN
 		ErrorOr(Error&& error)
 			: m_data(move(error))
 		{}
+		ErrorOr(ErrorOr&& other)
+			: m_data(move(other.m_data))
+		{}
+		ErrorOr& operator=(ErrorOr&& other)
+		{
+			m_data = move(other.m_data);
+			return *this;
+		}
 
 		bool is_error() const			{ return m_data.template has<Error>(); }
 		const Error& error() const		{ return m_data.template get<Error>(); }

BAN/include/BAN/Formatter.h

@@ -10,22 +10,19 @@ namespace BAN::Formatter
 
 	struct ValueFormat;
 
-	template<typename F>
-	static void print(F putc, const char* format);
-
-	template<typename F, typename Arg, typename... Args>
-	static void print(F putc, const char* format, Arg&& arg, Args&&... args);
-
 	template<typename F, typename... Args>
-	static void println(F putc, const char* format, Args&&... args);
+	concept PrintableArguments = requires(F putc, Args&&... args, const ValueFormat& format)
+	{
+		(print_argument(putc, BAN::forward<Args>(args), format), ...);
+	};
 
 	template<typename F, typename T>
-	static void print_argument(F putc, T value, const ValueFormat& format);
+	inline void print_argument(F putc, T value, const ValueFormat& format);
 
 	namespace detail
 	{
 		template<typename F, typename T>
-		static size_t parse_format_and_print_argument(F putc, const char* format, T&& arg);
+		inline size_t parse_format_and_print_argument(F putc, const char* format, T&& arg);
 	}
 
 	/*
@@ -39,11 +36,12 @@ namespace BAN::Formatter
 		int base		= 10;
 		int percision	= 3;
 		int fill		= 0;
+		char fill_char  = '0';
 		bool upper		= false;
 	};
 
 	template<typename F>
-	void print(F putc, const char* format)
+	inline void print(F putc, const char* format)
 	{
 		while (*format)
 		{
@@ -52,8 +50,8 @@ namespace BAN::Formatter
 		}
 	}
 
-	template<typename F, typename Arg, typename... Args>
-	void print(F putc, const char* format, Arg&& arg, Args&&... args)
+	template<typename F, typename Arg, typename... Args> requires PrintableArguments<F, Arg, Args...>
+	inline void print(F putc, const char* format, Arg&& arg, Args&&... args)
 	{
 		while (*format && *format != '{')
 		{
@@ -71,7 +69,7 @@ namespace BAN::Formatter
 	}
 
 	template<typename F, typename... Args>
-	void println(F putc, const char* format, Args&&... args)
+	inline void println(F putc, const char* format, Args&&... args)
 	{
 		print(putc, format, args...);
 		putc('\n');
@@ -81,7 +79,7 @@ namespace BAN::Formatter
 	{
 
 		template<typename F, typename Arg>
-		size_t parse_format_and_print_argument(F putc, const char* format, Arg&& argument)
+		inline size_t parse_format_and_print_argument(F putc, const char* format, Arg&& argument)
 		{
 			ValueFormat value_format;
 
@@ -94,6 +92,12 @@ namespace BAN::Formatter
 				if (!format[i] || format[i] == '}')
 					break;
 
+				if (format[i] == ' ')
+				{
+					value_format.fill_char = ' ';
+					i++;
+				}
+
 				if ('0' <= format[i] && format[i] <= '9')
 				{
 					int fill = 0;
@@ -143,7 +147,7 @@ namespace BAN::Formatter
 			return i + 1;
 		}
 
-		static char value_to_base_char(uint8_t value, int base, bool upper)
+		inline char value_to_base_char(uint8_t value, int base, bool upper)
 		{
 			if (base <= 10)
 				return value + '0';
@@ -157,12 +161,13 @@ namespace BAN::Formatter
 		}
 
 		template<typename F, typename T>
-		void print_integer(F putc, T value, const ValueFormat& format)
+		inline void print_integer(F putc, T value, const ValueFormat& format)
 		{
 			if (value == 0)
 			{
-				for (int i = 0; i < format.fill || i < 1; i++)
-					putc('0');
+				for (int i = 0; i < format.fill - 1; i++)
+					putc(format.fill_char);
+				putc('0');
 				return;
 			}
 
@@ -188,7 +193,7 @@ namespace BAN::Formatter
 			}
 
 			while (ptr >= buffer + sizeof(buffer) - format.fill)
-				*(--ptr) = '0';
+				*(--ptr) = format.fill_char;
 
 			if (sign)
 				*(--ptr) = '-';
@@ -197,12 +202,16 @@ namespace BAN::Formatter
 		}
 
 		template<typename F, typename T>
-		void print_floating(F putc, T value, const ValueFormat& format)
+		inline void print_floating(F putc, T value, const ValueFormat& format)
 		{
+			if (value < 0)
+			{
+				putc('-');
+				return print_floating(putc, -value, format);
+			}
+
 			int64_t int_part = (int64_t)value;
 			T frac_part = value - (T)int_part;
-			if (frac_part < 0)
-				frac_part = -frac_part;
 
 			print_integer(putc, int_part, format);
 
@@ -220,7 +229,7 @@ namespace BAN::Formatter
 		}
 
 		template<typename F>
-		void print_pointer(F putc, void* ptr, const ValueFormat& format)
+		inline void print_pointer(F putc, void* ptr, const ValueFormat& format)
 		{
 			uintptr_t value = (uintptr_t)ptr;
 			print(putc, "0x");
@@ -236,13 +245,13 @@ namespace BAN::Formatter
 
 	*/
 
-	template<typename F, integral		T> void print_argument(F putc, T value, const ValueFormat& format) { detail::print_integer(putc, value, format); }
-	template<typename F, floating_point	T> void print_argument(F putc, T value, const ValueFormat& format) { detail::print_floating(putc, value, format); }
-	template<typename F, pointer		T> void print_argument(F putc, T value, const ValueFormat& format) { detail::print_pointer(putc, (void*)value, format); }
+	template<typename F, integral		T> inline void print_argument(F putc, T value, const ValueFormat& format) { detail::print_integer(putc, value, format); }
+	template<typename F, floating_point	T> inline void print_argument(F putc, T value, const ValueFormat& format) { detail::print_floating(putc, value, format); }
+	template<typename F, pointer		T> inline void print_argument(F putc, T value, const ValueFormat& format) { detail::print_pointer(putc, (void*)value, format); }
 
-	template<typename F> void print_argument(F putc, char			value, const ValueFormat&)	{ putc(value); }
-	template<typename F> void print_argument(F putc, bool			value, const ValueFormat&)	{ print(putc, value ? "true" : "false"); }
-	template<typename F> void print_argument(F putc, const char*	value, const ValueFormat&)	{ print(putc, value); }
-	template<typename F> void print_argument(F putc, char*			value, const ValueFormat&)	{ print(putc, value); }
+	template<typename F> inline void print_argument(F putc, char			value, const ValueFormat&)	{ putc(value); }
+	template<typename F> inline void print_argument(F putc, bool			value, const ValueFormat&)	{ print(putc, value ? "true" : "false"); }
+	template<typename F> inline void print_argument(F putc, const char*	value, const ValueFormat&)	{ print(putc, value); }
+	template<typename F> inline void print_argument(F putc, char*			value, const ValueFormat&)	{ print(putc, value); }
 
 }

BAN/include/BAN/Function.h

@@ -20,19 +20,19 @@ namespace BAN
 			new (m_storage) CallablePointer(function);
 		}
 		template<typename Own>
-		Function(Ret(Own::*function)(Args...), Own* owner)
+		Function(Ret(Own::*function)(Args...), Own& owner)
 		{
 			static_assert(sizeof(CallableMember<Own>) <= m_size);
 			new (m_storage) CallableMember<Own>(function, owner);
 		}
 		template<typename Own>
-		Function(Ret(Own::*function)(Args...) const, const Own* owner)
+		Function(Ret(Own::*function)(Args...) const, const Own& owner)
 		{
 			static_assert(sizeof(CallableMemberConst<Own>) <= m_size);
 			new (m_storage) CallableMemberConst<Own>(function, owner);
 		}
 		template<typename Lambda>
-		Function(Lambda lambda)
+		Function(Lambda lambda) requires requires(Lambda lamda, Args&&... args) { { lambda(forward<Args>(args)...) } -> BAN::same_as<Ret>; }
 		{
 			static_assert(sizeof(CallableLambda<Lambda>) <= m_size);
 			new (m_storage) CallableLambda<Lambda>(lambda);
@@ -91,36 +91,36 @@ namespace BAN
 		template<typename Own>
 		struct CallableMember : public CallableBase
 		{
-			CallableMember(Ret(Own::*function)(Args...), Own* owner)
+			CallableMember(Ret(Own::*function)(Args...), Own& owner)
 				: m_owner(owner)
 				, m_function(function)
 			{ }
 
 			virtual Ret call(Args... args) const override
 			{
-				return (m_owner->*m_function)(forward<Args>(args)...);
+				return (m_owner.*m_function)(forward<Args>(args)...);
 			}
 
 		private:
-			Own* m_owner = nullptr;
+			Own& m_owner;
 			Ret(Own::*m_function)(Args...) = nullptr;
 		};
 
 		template<typename Own>
 		struct CallableMemberConst : public CallableBase
 		{
-			CallableMemberConst(Ret(Own::*function)(Args...) const, const Own* owner)
+			CallableMemberConst(Ret(Own::*function)(Args...) const, const Own& owner)
 				: m_owner(owner)
 				, m_function(function)
 			{ }
 
 			virtual Ret call(Args... args) const override
 			{
-				return (m_owner->*m_function)(forward<Args>(args)...);
+				return (m_owner.*m_function)(forward<Args>(args)...);
 			}
 
 		private:
-			const Own* m_owner = nullptr;
+			const Own& m_owner;
 			Ret(Own::*m_function)(Args...) const = nullptr;
 		};
 
@@ -141,7 +141,7 @@ namespace BAN
 		};
 
 	private:
-		static constexpr size_t m_size = sizeof(void*) * 5;
+		static constexpr size_t m_size = sizeof(void*) * 8;
 		alignas(CallableBase) uint8_t m_storage[m_size] { 0 };
 	};
 

BAN/include/BAN/GUID.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <BAN/Optional.h>
-#include <BAN/StringView.h>
+#include <BAN/String.h>
 
 #include <string.h>
 
@@ -19,6 +19,54 @@ namespace BAN
 		{
 			return memcmp(this, &other, sizeof(GUID)) == 0;
 		}
+
+		BAN::ErrorOr<BAN::String> to_string() const
+		{
+			char buffer[37];
+			char* ptr = buffer;
+
+			const auto append_hex_nibble =
+				[&ptr](uint8_t nibble)
+				{
+					if (nibble < 10)
+						*ptr++ = '0' + nibble;
+					else
+						*ptr++ = 'A' + nibble - 10;
+				};
+
+			const auto append_hex_byte =
+				[&append_hex_nibble](uint8_t byte)
+				{
+					append_hex_nibble(byte >> 4);
+					append_hex_nibble(byte & 0xF);
+				};
+
+			append_hex_byte((component1 >> 24) & 0xFF);
+			append_hex_byte((component1 >> 16) & 0xFF);
+			append_hex_byte((component1 >>  8) & 0xFF);
+			append_hex_byte((component1 >>  0) & 0xFF);
+			*ptr++ = '-';
+			append_hex_byte((component2 >>  8) & 0xFF);
+			append_hex_byte((component2 >>  0) & 0xFF);
+			*ptr++ = '-';
+			append_hex_byte((component3 >>  8) & 0xFF);
+			append_hex_byte((component3 >>  0) & 0xFF);
+			*ptr++ = '-';
+			append_hex_byte(component45[0]);
+			append_hex_byte(component45[1]);
+			*ptr++ = '-';
+			append_hex_byte(component45[2]);
+			append_hex_byte(component45[3]);
+			append_hex_byte(component45[4]);
+			append_hex_byte(component45[5]);
+			append_hex_byte(component45[6]);
+			append_hex_byte(component45[7]);
+			*ptr = '\0';
+
+			BAN::String guid;
+			TRY(guid.append(buffer));
+			return BAN::move(guid);
+		}
 	};
 	static_assert(sizeof(GUID) == 16);
 

BAN/include/BAN/HashMap.h

@@ -14,11 +14,17 @@ namespace BAN
 		struct Entry
 		{
 			template<typename... Args>
-			Entry(const Key& key, Args&&... args)
+			Entry(const Key& key, Args&&... args) requires is_constructible_v<T, Args...>
 				: key(key)
 				, value(forward<Args>(args)...)
 			{}
 
+			template<typename... Args>
+			Entry(Key&& key, Args&&... args) requires is_constructible_v<T, Args...>
+				: key(BAN::move(key))
+				, value(forward<Args>(args)...)
+			{}
+
 			Key key;
 			T value;
 		};
@@ -39,10 +45,27 @@ namespace BAN
 		HashMap<Key, T, HASH>& operator=(const HashMap<Key, T, HASH>&);
 		HashMap<Key, T, HASH>& operator=(HashMap<Key, T, HASH>&&);
 
-		ErrorOr<void> insert(const Key&, const T&);
-		ErrorOr<void> insert(const Key&, T&&);
+		ErrorOr<iterator> insert(const Key& key, const T& value)           { return emplace(key, value); }
+		ErrorOr<iterator> insert(const Key& key, T&& value)                { return emplace(key, move(value)); }
+		ErrorOr<iterator> insert(Key&& key, const T& value)                { return emplace(move(key), value); }
+		ErrorOr<iterator> insert(Key&& key, T&& value)                     { return emplace(move(key), move(value)); }
+
+		ErrorOr<iterator> insert_or_assign(const Key& key, const T& value) { return emplace_or_assign(key, value); }
+		ErrorOr<iterator> insert_or_assign(const Key& key, T&& value)      { return emplace_or_assign(key, move(value)); }
+		ErrorOr<iterator> insert_or_assign(Key&& key, const T& value)      { return emplace_or_assign(move(key), value); }
+		ErrorOr<iterator> insert_or_assign(Key&& key, T&& value)           { return emplace_or_assign(move(key), move(value)); }
+
 		template<typename... Args>
-		ErrorOr<void> emplace(const Key&, Args&&...);
+		ErrorOr<iterator> emplace(const Key& key, Args&&... args) requires is_constructible_v<T, Args...>
+		{ return emplace(Key(key), forward<Args>(args)...); }
+		template<typename... Args>
+		ErrorOr<iterator> emplace(Key&&, Args&&...) requires is_constructible_v<T, Args...>;
+
+		template<typename... Args>
+		ErrorOr<iterator> emplace_or_assign(const Key& key, Args&&... args) requires is_constructible_v<T, Args...>
+		{ return emplace_or_assign(Key(key), forward<Args>(args)...); }
+		template<typename... Args>
+		ErrorOr<iterator> emplace_or_assign(Key&&, Args&&...) requires is_constructible_v<T, Args...>;
 
 		iterator begin() { return iterator(m_buckets.end(), m_buckets.begin()); }
 		iterator end()   { return iterator(m_buckets.end(), m_buckets.end()); }
@@ -117,27 +140,36 @@ namespace BAN
 	}
 
 	template<typename Key, typename T, typename HASH>
-	ErrorOr<void> HashMap<Key, T, HASH>::insert(const Key& key, const T& value)
+	template<typename... Args>
+	ErrorOr<typename HashMap<Key, T, HASH>::iterator> HashMap<Key, T, HASH>::emplace(Key&& key, Args&&... args) requires is_constructible_v<T, Args...>
 	{
-		return insert(key, move(T(value)));
-	}
+		ASSERT(!contains(key));
+		TRY(rebucket(m_size + 1));
 
-	template<typename Key, typename T, typename HASH>
-	ErrorOr<void> HashMap<Key, T, HASH>::insert(const Key& key, T&& value)
-	{
-		return emplace(key, move(value));
+		auto bucket_it = get_bucket_iterator(key);
+		TRY(bucket_it->emplace_back(move(key), forward<Args>(args)...));
+		m_size++;
+
+		return iterator(m_buckets.end(), bucket_it, prev(bucket_it->end(), 1));
 	}
 
 	template<typename Key, typename T, typename HASH>
 	template<typename... Args>
-	ErrorOr<void> HashMap<Key, T, HASH>::emplace(const Key& key, Args&&... args)
+	ErrorOr<typename HashMap<Key, T, HASH>::iterator> HashMap<Key, T, HASH>::emplace_or_assign(Key&& key, Args&&... args) requires is_constructible_v<T, Args...>
 	{
-		ASSERT(!contains(key));
-		TRY(rebucket(m_size + 1));
-		auto& bucket = get_bucket(key);
-		TRY(bucket.emplace_back(key, forward<Args>(args)...));
-		m_size++;
-		return {};
+		if (empty())
+			return emplace(move(key), forward<Args>(args)...);
+
+		auto bucket_it = get_bucket_iterator(key);
+		for (auto entry_it = bucket_it->begin(); entry_it != bucket_it->end(); entry_it++)
+		{
+			if (entry_it->key != key)
+				continue;
+			entry_it->value = T(forward<Args>(args)...);
+			return iterator(m_buckets.end(), bucket_it, entry_it);
+		}
+
+		return emplace(move(key), forward<Args>(args)...);
 	}
 
 	template<typename Key, typename T, typename HASH>
@@ -177,7 +209,7 @@ namespace BAN
 		for (Entry& entry : bucket)
 			if (entry.key == key)
 				return entry.value;
-		ASSERT(false);
+		ASSERT_NOT_REACHED();
 	}
 
 	template<typename Key, typename T, typename HASH>
@@ -188,7 +220,7 @@ namespace BAN
 		for (const Entry& entry : bucket)
 			if (entry.key == key)
 				return entry.value;
-		ASSERT(false);
+		ASSERT_NOT_REACHED();
 	}
 
 	template<typename Key, typename T, typename HASH>

BAN/include/BAN/Heap.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <BAN/Iterators.h>
+#include <BAN/Swap.h>
+#include <BAN/Traits.h>
+
+namespace BAN
+{
+
+	namespace detail
+	{
+
+		template<typename It, typename Comp>
+		void heapify_up(It begin, size_t index, Comp comp)
+		{
+			size_t parent = (index - 1) / 2;
+			while (parent < index)
+			{
+				if (comp(*(begin + index), *(begin + parent)))
+					break;
+				swap(*(begin + parent), *(begin + index));
+				index = parent;
+				parent = (index - 1) / 2;
+			}
+		}
+
+		template<typename It, typename Comp>
+		void heapify_down(It begin, size_t index, size_t len, Comp comp)
+		{
+			for (;;)
+			{
+				const size_t lchild = 2 * index + 1;
+				const size_t rchild = 2 * index + 2;
+
+				size_t child = 0;
+				if (lchild < len && !comp(*(begin + lchild), *(begin + index)))
+				{
+					if (rchild < len && !comp(*(begin + rchild), *(begin + lchild)))
+						child = rchild;
+					else
+						child = lchild;
+				}
+				else if (rchild < len && !comp(*(begin + rchild), *(begin + index)))
+					child = rchild;
+				else
+					break;
+
+				swap(*(begin + child), *(begin + index));
+				index = child;
+			}
+		}
+
+	}
+
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
+	void make_heap(It begin, It end, Comp comp = {})
+	{
+		const size_t len = distance(begin, end);
+		if (len <= 1)
+			return;
+
+		size_t index = (len - 2) / 2;
+		while (index < len)
+			detail::heapify_down(begin, index--, len, comp);
+	}
+
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
+	void push_heap(It begin, It end, Comp comp = {})
+	{
+		const size_t len = distance(begin, end);
+		detail::heapify_up(begin, len - 1, comp);
+	}
+
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
+	void pop_heap(It begin, It end, Comp comp = {})
+	{
+		const size_t len = distance(begin, end);
+		swap(*begin, *(begin + len - 1));
+		detail::heapify_down(begin, 0, len - 1, comp);
+	}
+
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
+	void sort_heap(It begin, It end, Comp comp = {})
+	{
+		while (begin != end)
+			pop_heap(begin, end--, comp);
+	}
+
+}

BAN/include/BAN/IPv4.h

@@ -9,6 +9,10 @@ namespace BAN
 
 	struct IPv4Address
 	{
+		constexpr IPv4Address()
+			: IPv4Address(0)
+		{ }
+
 		constexpr IPv4Address(uint32_t u32_address)
 		{
 			raw = u32_address;

BAN/include/BAN/Iterators.h

@@ -9,7 +9,7 @@ namespace BAN
 {
 
 	template<typename It>
-	It next(It it, size_t count)
+	constexpr It next(It it, size_t count)
 	{
 		for (size_t i = 0; i < count; i++)
 			++it;
@@ -18,13 +18,13 @@ namespace BAN
 
 	template<typename It>
 	requires requires(It it, size_t n) { requires is_same_v<decltype(it + n), It>; }
-	It next(It it, size_t count)
+	constexpr It next(It it, size_t count)
 	{
 		return it + count;
 	}
 
 	template<typename It>
-	It prev(It it, size_t count)
+	constexpr It prev(It it, size_t count)
 	{
 		for (size_t i = 0; i < count; i++)
 			--it;
@@ -33,13 +33,13 @@ namespace BAN
 
 	template<typename It>
 	requires requires(It it, size_t n) { requires is_same_v<decltype(it - n), It>; }
-	It prev(It it, size_t count)
+	constexpr It prev(It it, size_t count)
 	{
 		return it - count;
 	}
 
 	template<typename It>
-	size_t distance(It it1, It it2)
+	constexpr size_t distance(It it1, It it2)
 	{
 		size_t dist = 0;
 		while (it1 != it2)
@@ -52,7 +52,7 @@ namespace BAN
 
 	template<typename It>
 	requires requires(It it1, It it2) { requires is_integral_v<decltype(it2 - it1)>; }
-	size_t distance(It it1, It it2)
+	constexpr size_t distance(It it1, It it2)
 	{
 		return it2 - it1;
 	}
@@ -64,109 +64,109 @@ namespace BAN
 		using value_type = T;
 
 	public:
-		IteratorSimpleGeneral() = default;
+		constexpr IteratorSimpleGeneral() = default;
 		template<bool CONST2, typename = enable_if_t<CONST2 == CONST || CONST>>
-		IteratorSimpleGeneral(const IteratorSimpleGeneral<T, Container, CONST2>& other)
+		constexpr IteratorSimpleGeneral(const IteratorSimpleGeneral<T, Container, CONST2>& other)
 			: m_pointer(other.m_pointer)
 			, m_valid(other.m_valid)
 		{
 		}
 
-		const T& operator*() const
+		constexpr const T& operator*() const
 		{
 			ASSERT(m_pointer);
 			return *m_pointer;
 		}
 		template<bool CONST2 = CONST>
-		enable_if_t<!CONST2, T&> operator*()
+		constexpr enable_if_t<!CONST2, T&> operator*()
 		{
 			ASSERT(*this);
 			ASSERT(m_pointer);
 			return *m_pointer;
 		}
 
-		const T* operator->() const
+		constexpr const T* operator->() const
 		{
 			ASSERT(*this);
 			ASSERT(m_pointer);
 			return m_pointer;
 		}
 		template<bool CONST2 = CONST>
-		enable_if_t<!CONST2, T*> operator->()
+		constexpr enable_if_t<!CONST2, T*> operator->()
 		{
 			ASSERT(*this);
 			ASSERT(m_pointer);
 			return m_pointer;
 		}
 
-		IteratorSimpleGeneral& operator++()
+		constexpr IteratorSimpleGeneral& operator++()
 		{
 			ASSERT(*this);
 			ASSERT(m_pointer);
 			++m_pointer;
 			return *this;
 		}
-		IteratorSimpleGeneral operator++(int)
+		constexpr IteratorSimpleGeneral operator++(int)
 		{
 			auto temp = *this;
 			++(*this);
 			return temp;
 		}
 
-		IteratorSimpleGeneral& operator--()
+		constexpr IteratorSimpleGeneral& operator--()
 		{
 			ASSERT(*this);
 			ASSERT(m_pointer);
 			--m_pointer;
 			return *this;
 		}
-		IteratorSimpleGeneral operator--(int)
+		constexpr IteratorSimpleGeneral operator--(int)
 		{
 			auto temp = *this;
 			--(*this);
 			return temp;
 		}
 
-		size_t operator-(const IteratorSimpleGeneral& other) const
+		constexpr size_t operator-(const IteratorSimpleGeneral& other) const
 		{
 			ASSERT(*this && other);
 			return m_pointer - other.m_pointer;
 		}
 
-		IteratorSimpleGeneral operator+(size_t offset) const
+		constexpr IteratorSimpleGeneral operator+(size_t offset) const
 		{
 			return IteratorSimpleGeneral(m_pointer + offset);
 		}
 
-		IteratorSimpleGeneral operator-(size_t offset) const
+		constexpr IteratorSimpleGeneral operator-(size_t offset) const
 		{
 			return IteratorSimpleGeneral(m_pointer - offset);
 		}
 
-		bool operator<(const IteratorSimpleGeneral& other) const
+		constexpr bool operator<(const IteratorSimpleGeneral& other) const
 		{
 			ASSERT(*this);
 			return m_pointer < other.m_pointer;
 		}
 
-		bool operator==(const IteratorSimpleGeneral& other) const
+		constexpr bool operator==(const IteratorSimpleGeneral& other) const
 		{
 			ASSERT(*this);
 			return m_pointer == other.m_pointer;
 		}
-		bool operator!=(const IteratorSimpleGeneral& other) const
+		constexpr bool operator!=(const IteratorSimpleGeneral& other) const
 		{
 			ASSERT(*this);
 			return !(*this == other);
 		}
 
-		explicit operator bool() const
+		constexpr explicit operator bool() const
 		{
 			return m_valid;
 		}
 
 	private:
-		IteratorSimpleGeneral(maybe_const_t<CONST, T>* pointer)
+		constexpr IteratorSimpleGeneral(maybe_const_t<CONST, T>* pointer)
 			: m_pointer(pointer)
 			, m_valid(true)
 		{
@@ -193,16 +193,16 @@ namespace BAN
 		using value_type = T;
 
 	public:
-		IteratorDoubleGeneral() = default;
+		constexpr IteratorDoubleGeneral() = default;
 		template<bool CONST2, typename = enable_if_t<CONST2 == CONST || CONST>>
-		IteratorDoubleGeneral(const IteratorDoubleGeneral<T, OuterContainer, InnerContainer, Container, CONST2>& other)
+		constexpr IteratorDoubleGeneral(const IteratorDoubleGeneral<T, OuterContainer, InnerContainer, Container, CONST2>& other)
 			: m_outer_end(other.m_outer_end)
 			, m_outer_current(other.m_outer_current)
 			, m_inner_current(other.m_inner_current)
 		{
 		}
 
-		const T& operator*() const
+		constexpr const T& operator*() const
 		{
 			ASSERT(*this);
 			ASSERT(m_outer_current != m_outer_end);
@@ -210,7 +210,7 @@ namespace BAN
 			return m_inner_current.operator*();
 		}
 		template<bool CONST2 = CONST>
-		enable_if_t<!CONST2, T&> operator*()
+		constexpr enable_if_t<!CONST2, T&> operator*()
 		{
 			ASSERT(*this);
 			ASSERT(m_outer_current != m_outer_end);
@@ -218,7 +218,7 @@ namespace BAN
 			return m_inner_current.operator*();
 		}
 
-		const T* operator->() const
+		constexpr const T* operator->() const
 		{
 			ASSERT(*this);
 			ASSERT(m_outer_current != m_outer_end);
@@ -226,7 +226,7 @@ namespace BAN
 			return m_inner_current.operator->();
 		}
 		template<bool CONST2 = CONST>
-		enable_if_t<!CONST2, T*> operator->()
+		constexpr enable_if_t<!CONST2, T*> operator->()
 		{
 			ASSERT(*this);
 			ASSERT(m_outer_current != m_outer_end);
@@ -234,7 +234,7 @@ namespace BAN
 			return m_inner_current.operator->();
 		}
 
-		IteratorDoubleGeneral& operator++()
+		constexpr IteratorDoubleGeneral& operator++()
 		{
 			ASSERT(*this);
 			ASSERT(m_outer_current != m_outer_end);
@@ -243,14 +243,14 @@ namespace BAN
 			find_valid_or_end();
 			return *this;
 		}
-		IteratorDoubleGeneral operator++(int)
+		constexpr IteratorDoubleGeneral operator++(int)
 		{
 			auto temp = *this;
 			++(*this);
 			return temp;
 		}
 
-		bool operator==(const IteratorDoubleGeneral& other) const
+		constexpr bool operator==(const IteratorDoubleGeneral& other) const
 		{
 			ASSERT(*this && other);
 			if (m_outer_end != other.m_outer_end)
@@ -262,18 +262,18 @@ namespace BAN
 			ASSERT(m_inner_current && other.m_inner_current);
 			return m_inner_current == other.m_inner_current;
 		}
-		bool operator!=(const IteratorDoubleGeneral& other) const
+		constexpr bool operator!=(const IteratorDoubleGeneral& other) const
 		{
 			return !(*this == other);
 		}
 
-		explicit operator bool() const
+		constexpr explicit operator bool() const
 		{
 			return !!m_outer_current;
 		}
 
 	private:
-		IteratorDoubleGeneral(const OuterIterator& outer_end, const OuterIterator& outer_current)
+		constexpr IteratorDoubleGeneral(const OuterIterator& outer_end, const OuterIterator& outer_current)
 			: m_outer_end(outer_end)
 			, m_outer_current(outer_current)
 		{
@@ -284,7 +284,7 @@ namespace BAN
 			}
 		}
 
-		IteratorDoubleGeneral(const OuterIterator& outer_end, const OuterIterator& outer_current, const InnerIterator& inner_current)
+		constexpr IteratorDoubleGeneral(const OuterIterator& outer_end, const OuterIterator& outer_current, const InnerIterator& inner_current)
 			: m_outer_end(outer_end)
 			, m_outer_current(outer_current)
 			, m_inner_current(inner_current)
@@ -292,7 +292,7 @@ namespace BAN
 			find_valid_or_end();
 		}
 
-		void find_valid_or_end()
+		constexpr void find_valid_or_end()
 		{
 			while (m_inner_current == m_outer_current->end())
 			{
@@ -303,8 +303,8 @@ namespace BAN
 			}
 		}
 
-		OuterIterator outer_current() { return m_outer_current; }
-		InnerIterator inner_current() { return m_inner_current; }
+		constexpr OuterIterator outer_current() { return m_outer_current; }
+		constexpr InnerIterator inner_current() { return m_inner_current; }
 
 	private:
 		OuterIterator m_outer_end;

BAN/include/BAN/LinkedList.h

@@ -34,9 +34,9 @@ namespace BAN
 		ErrorOr<void> insert(iterator, const T&);
 		ErrorOr<void> insert(iterator, T&&);
 		template<typename... Args>
-		ErrorOr<void> emplace_back(Args&&...);
+		ErrorOr<void> emplace_back(Args&&...) requires is_constructible_v<T, Args...>;
 		template<typename... Args>
-		ErrorOr<void> emplace(iterator, Args&&...);
+		ErrorOr<void> emplace(iterator, Args&&...) requires is_constructible_v<T, Args...>;
 
 		void pop_back();
 		iterator remove(iterator);
@@ -196,14 +196,14 @@ namespace BAN
 
 	template<typename T>
 	template<typename... Args>
-	ErrorOr<void> LinkedList<T>::emplace_back(Args&&... args)
+	ErrorOr<void> LinkedList<T>::emplace_back(Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		return emplace(end(), forward<Args>(args)...);
 	}
 
 	template<typename T>
 	template<typename... Args>
-	ErrorOr<void> LinkedList<T>::emplace(iterator iter, Args&&... args)
+	ErrorOr<void> LinkedList<T>::emplace(iterator iter, Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		Node* new_node = TRY(allocate_node(forward<Args>(args)...));
 		insert_node(iter, new_node);

BAN/include/BAN/Math.h

@@ -1,17 +1,18 @@
 #pragma once
 
+#include <BAN/Limits.h>
+#include <BAN/Numbers.h>
 #include <BAN/Traits.h>
 
-#include <stddef.h>
-#include <stdint.h>
+#include <float.h>
 
 namespace BAN::Math
 {
 
 	template<typename T>
-	inline constexpr T abs(T val)
+	inline constexpr T abs(T x)
 	{
-		return val < 0 ? -val : val;
+		return x < 0 ? -x : x;
 	}
 
 	template<typename T>
@@ -35,12 +36,11 @@ namespace BAN::Math
 	template<integral T>
 	inline constexpr T gcd(T a, T b)
 	{
-		T t;
 		while (b)
 		{
-			t = b;
+			T temp = b;
 			b = a % b;
-			a = t;
+			a = temp;
 		}
 		return a;
 	}
@@ -58,65 +58,408 @@ namespace BAN::Math
 	}
 
 	template<integral T>
-	inline constexpr bool is_power_of_two(T value)
+	inline constexpr bool is_power_of_two(T x)
 	{
-		if (value == 0)
+		if (x == 0)
 			return false;
-		return (value & (value - 1)) == 0;
+		return (x & (x - 1)) == 0;
+	}
+
+	template<integral T>
+	__attribute__((always_inline))
+	inline constexpr bool will_multiplication_overflow(T a, T b)
+	{
+		T dummy;
+		return __builtin_mul_overflow(a, b, &dummy);
+	}
+
+	template<integral T>
+	__attribute__((always_inline))
+	inline constexpr bool will_addition_overflow(T a, T b)
+	{
+		T dummy;
+		return __builtin_add_overflow(a, b, &dummy);
 	}
 
 	template<typename T>
 	requires is_same_v<T, unsigned int> || is_same_v<T, unsigned long> || is_same_v<T, unsigned long long>
-	inline constexpr T ilog2(T value)
+	inline constexpr T ilog2(T x)
 	{
 		if constexpr(is_same_v<T, unsigned int>)
-			return sizeof(T) * 8 - __builtin_clz(value) - 1;
+			return sizeof(T) * 8 - __builtin_clz(x) - 1;
 		if constexpr(is_same_v<T, unsigned long>)
-			return sizeof(T) * 8 - __builtin_clzl(value) - 1;
-		return sizeof(T) * 8 - __builtin_clzll(value) - 1;
+			return sizeof(T) * 8 - __builtin_clzl(x) - 1;
+		return sizeof(T) * 8 - __builtin_clzll(x) - 1;
+	}
+
+// This is ugly but my clangd does not like including
+// intrinsic headers at all
+#if !defined(__SSE__) || !defined(__SSE2__)
+#pragma GCC push_options
+#ifndef __SSE__
+#pragma GCC target("sse")
+#endif
+#ifndef __SSE2__
+#pragma GCC target("sse2")
+#endif
+#define BAN_MATH_POP_OPTIONS
+#endif
+
+	template<floating_point T>
+	inline constexpr T floor(T x)
+	{
+		if constexpr(is_same_v<T, float>)
+			return __builtin_floorf(x);
+		if constexpr(is_same_v<T, double>)
+			return __builtin_floor(x);
+		if constexpr(is_same_v<T, long double>)
+			return __builtin_floorl(x);
 	}
 
 	template<floating_point T>
-	inline constexpr T log2(T value)
+	inline constexpr T ceil(T x)
 	{
-		T result;
-		asm volatile("fyl2x" : "=t"(result) : "0"(value), "u"((T)1.0) : "st(1)");
-		return result;
+		if constexpr(is_same_v<T, float>)
+			return __builtin_ceilf(x);
+		if constexpr(is_same_v<T, double>)
+			return __builtin_ceil(x);
+		if constexpr(is_same_v<T, long double>)
+			return __builtin_ceill(x);
 	}
 
 	template<floating_point T>
-	inline constexpr T log10(T value)
+	inline constexpr T round(T x)
 	{
-		constexpr T INV_LOG_2_10 = 0.3010299956639811952137388947244930267681898814621085413104274611;
-		T result;
-		asm volatile("fyl2x" : "=t"(result) : "0"(value), "u"(INV_LOG_2_10) : "st(1)");
-		return result;
+		if (x == (T)0.0)
+			return x;
+		if (x > (T)0.0)
+			return floor<T>(x + (T)0.5);
+		return ceil<T>(x - (T)0.5);
 	}
 
 	template<floating_point T>
-	inline constexpr T log(T value, T base)
+	inline constexpr T trunc(T x)
 	{
-		return log2(value) / log2(base);
+		if constexpr(is_same_v<T, float>)
+			return __builtin_truncf(x);
+		if constexpr(is_same_v<T, double>)
+			return __builtin_trunc(x);
+		if constexpr(is_same_v<T, long double>)
+			return __builtin_truncl(x);
 	}
 
 	template<floating_point T>
-	inline constexpr T pow(T base, T exp)
+	inline constexpr T rint(T x)
 	{
-		T result;
-		asm volatile(
-			"fyl2x;"
+		asm("frndint" : "+t"(x));
+		return x;
+	}
+
+	template<floating_point T>
+	inline constexpr T fmod(T a, T b)
+	{
+		asm(
+			"1:"
+			"fprem;"
+			"fnstsw %%ax;"
+			"testb $4, %%ah;"
+			"jne 1b;"
+			: "+t"(a)
+			: "u"(b)
+			: "ax", "cc"
+		);
+		return a;
+	}
+
+	template<floating_point T>
+	inline constexpr T remainder(T a, T b)
+	{
+		asm(
+			"1:"
+			"fprem1;"
+			"fnstsw %%ax;"
+			"testb $4, %%ah;"
+			"jne 1b;"
+			: "+t"(a)
+			: "u"(b)
+			: "ax", "cc"
+		);
+		return a;
+	}
+
+	template<floating_point T>
+	static T modf(T x, T* iptr)
+	{
+		const T frac = BAN::Math::fmod<T>(x, (T)1.0);
+		*iptr = x - frac;
+		return frac;
+	}
+
+	template<floating_point T>
+	inline constexpr T frexp(T num, int* exp)
+	{
+		if (num == (T)0.0)
+		{
+			*exp = 0;
+			return (T)0.0;
+		}
+
+		T e;
+		asm("fxtract" : "+t"(num), "=u"(e));
+		*exp = (int)e + 1;
+		return num / (T)2.0;
+	}
+
+	template<floating_point T>
+	inline constexpr T copysign(T x, T y)
+	{
+		if ((x < (T)0.0) != (y < (T)0.0))
+			x = -x;
+		return x;
+	}
+
+	namespace detail
+	{
+
+		template<floating_point T>
+		inline constexpr T fyl2x(T x, T y)
+		{
+			asm("fyl2x" : "+t"(x) : "u"(y) : "st(1)");
+			return x;
+		}
+
+	}
+
+	template<floating_point T>
+	inline constexpr T log(T x)
+	{
+		return detail::fyl2x<T>(x, numbers::ln2_v<T>);
+	}
+
+	template<floating_point T>
+	inline constexpr T log2(T x)
+	{
+		return detail::fyl2x<T>(x, 1.0);
+	}
+
+	template<floating_point T>
+	inline constexpr T log10(T x)
+	{
+		return detail::fyl2x<T>(x, numbers::lg2_v<T>);
+	}
+
+	template<floating_point T>
+	inline constexpr T logb(T x)
+	{
+		static_assert(FLT_RADIX == 2);
+		return log2<T>(x);
+	}
+
+	template<floating_point T>
+	inline constexpr T exp2(T x)
+	{
+		if (abs(x) <= (T)1.0)
+		{
+			asm("f2xm1" : "+t"(x));
+			return x + (T)1.0;
+		}
+
+		asm(
 			"fld1;"
 			"fld %%st(1);"
 			"fprem;"
 			"f2xm1;"
 			"faddp;"
 			"fscale;"
-			"fxch %%st(1);"
-			"fstp %%st;"
-			: "=t"(result)
-			: "0"(base), "u"(exp)
+			"fstp %%st(1);"
+			: "+t"(x)
 		);
-		return result;
+
+		return x;
 	}
 
+	template<floating_point T>
+	inline constexpr T exp(T x)
+	{
+		return exp2<T>(x * numbers::log2e_v<T>);
+	}
+
+	template<floating_point T>
+	inline constexpr T pow(T x, T y)
+	{
+		if (x == (T)0.0)
+			return (T)0.0;
+		return exp2<T>(y * log2<T>(x));
+	}
+
+	template<floating_point T>
+	inline constexpr T scalbn(T x, int n)
+	{
+		asm("fscale" : "+t"(x) : "u"(static_cast<T>(n)));
+		return x;
+	}
+
+	template<floating_point T>
+	inline constexpr T ldexp(T x, int y)
+	{
+		const bool exp_sign = y < 0;
+		if (exp_sign)
+			y = -y;
+
+		T exp = (T)1.0;
+		T mult = (T)2.0;
+		while (y)
+		{
+			if (y & 1)
+				exp *= mult;
+			mult *= mult;
+			y >>= 1;
+		}
+
+		if (exp_sign)
+			exp = (T)1.0 / exp;
+
+		return x * exp;
+	}
+
+	template<floating_point T>
+	inline constexpr T sqrt(T x)
+	{
+		if constexpr(BAN::is_same_v<T, float>)
+		{
+			using v4sf = float __attribute__((vector_size(16)));
+			return __builtin_ia32_sqrtss((v4sf) { x, 0.0f, 0.0f, 0.0f })[0];
+		}
+		else if constexpr(BAN::is_same_v<T, double>)
+		{
+			using v2df = double __attribute__((vector_size(16)));
+			return __builtin_ia32_sqrtsd((v2df) { x, 0.0 })[0];
+		}
+		else if constexpr(BAN::is_same_v<T, long double>)
+		{
+			asm("fsqrt" : "+t"(x));
+			return x;
+		}
+	}
+
+	template<floating_point T>
+	inline constexpr T cbrt(T value)
+	{
+		return pow<T>(value, (T)1.0 / (T)3.0);
+	}
+
+	template<floating_point T>
+	inline constexpr T sin(T x)
+	{
+		asm("fsin" : "+t"(x));
+		return x;
+	}
+
+	template<floating_point T>
+	inline constexpr T cos(T x)
+	{
+		asm("fcos" : "+t"(x));
+		return x;
+	}
+
+	template<floating_point T>
+	inline constexpr void sincos(T x, T& sin, T& cos)
+	{
+		asm("fsincos" : "=t"(cos), "=u"(sin) : "0"(x));
+	}
+
+	template<floating_point T>
+	inline constexpr T tan(T x)
+	{
+		T one, ret;
+		asm("fptan" : "=t"(one), "=u"(ret) : "0"(x));
+		return ret;
+	}
+
+	template<floating_point T>
+	inline constexpr T atan2(T y, T x)
+	{
+		asm("fpatan" : "+t"(x) : "u"(y) : "st(1)");
+		return x;
+	}
+
+	template<floating_point T>
+	inline constexpr T atan(T x)
+	{
+		return atan2<T>(x, (T)1.0);
+	}
+
+	template<floating_point T>
+	inline constexpr T asin(T x)
+	{
+		if (x == (T)0.0)
+			return (T)0.0;
+		if (x == (T)1.0)
+			return +numbers::pi_v<T> / (T)2.0;
+		if (x == (T)-1.0)
+			return -numbers::pi_v<T> / (T)2.0;
+		return (T)2.0 * atan<T>(x / ((T)1.0 + sqrt<T>((T)1.0 - x * x)));
+	}
+
+	template<floating_point T>
+	inline constexpr T acos(T x)
+	{
+		if (x == (T)0.0)
+			return numbers::pi_v<T> / (T)2.0;
+		if (x == (T)1.0)
+			return (T)0.0;
+		if (x == (T)-1.0)
+			return numbers::pi_v<T>;
+		return (T)2.0 * atan<T>(sqrt<T>((T)1.0 - x * x) / ((T)1.0 + x));
+	}
+
+	template<floating_point T>
+	inline constexpr T sinh(T x)
+	{
+		return (exp<T>(x) - exp<T>(-x)) / (T)2.0;
+	}
+
+	template<floating_point T>
+	inline constexpr T cosh(T x)
+	{
+		return (exp<T>(x) + exp<T>(-x)) / (T)2.0;
+	}
+
+	template<floating_point T>
+	inline constexpr T tanh(T x)
+	{
+		const T exp_px = exp<T>(+x);
+		const T exp_nx = exp<T>(-x);
+		return (exp_px - exp_nx) / (exp_px + exp_nx);
+	}
+
+	template<floating_point T>
+	inline constexpr T asinh(T x)
+	{
+		return log<T>(x + sqrt<T>(x * x + (T)1.0));
+	}
+
+	template<floating_point T>
+	inline constexpr T acosh(T x)
+	{
+		return log<T>(x + sqrt<T>(x * x - (T)1.0));
+	}
+
+	template<floating_point T>
+	inline constexpr T atanh(T x)
+	{
+		return (T)0.5 * log<T>(((T)1.0 + x) / ((T)1.0 - x));
+	}
+
+	template<floating_point T>
+	inline constexpr T hypot(T x, T y)
+	{
+		return sqrt<T>(x * x + y * y);
+	}
+
+#ifdef BAN_MATH_POP_OPTIONS
+#undef BAN_MATH_POP_OPTIONS
+#pragma GCC pop_options
+#endif
+
 }

BAN/include/BAN/New.h

@@ -9,10 +9,12 @@
 namespace BAN
 {
 	#if defined(__is_kernel)
-		static constexpr void*(&allocator)(size_t) = kmalloc;
-		static constexpr void(&deallocator)(void*) = kfree;
+		static constexpr void*(*allocator)(size_t) = kmalloc;
+		static constexpr void*(*reallocator)(void*, size_t) = nullptr;
+		static constexpr void(*deallocator)(void*) = kfree;
 	#else
-		static constexpr void*(&allocator)(size_t) = malloc;
-		static constexpr void(&deallocator)(void*) = free;
+		static constexpr void*(*allocator)(size_t) = malloc;
+		static constexpr void*(*reallocator)(void*, size_t) = realloc;
+		static constexpr void(*deallocator)(void*) = free;
 	#endif
 }

BAN/include/BAN/Numbers.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <BAN/Traits.h>
+
+namespace BAN::numbers
+{
+
+	template<floating_point T> inline constexpr T e_v      = 2.71828182845904523536;
+	template<floating_point T> inline constexpr T log2e_v  = 1.44269504088896340736;
+	template<floating_point T> inline constexpr T lge_v    = 0.43429448190325182765;
+	template<floating_point T> inline constexpr T lg2_v    = 0.30102999566398119521;
+	template<floating_point T> inline constexpr T ln2_v    = 0.69314718055994530942;
+	template<floating_point T> inline constexpr T ln10_v   = 2.30258509299404568402;
+	template<floating_point T> inline constexpr T pi_v     = 3.14159265358979323846;
+	template<floating_point T> inline constexpr T sqrt2_v  = 1.41421356237309504880;
+	template<floating_point T> inline constexpr T sqrt3_v  = 1.73205080756887729353;
+
+	inline constexpr double e      = e_v<double>;
+	inline constexpr double log2e  = log2e_v<double>;
+	inline constexpr double lge    = lge_v<double>;
+	inline constexpr double lg2    = lge_v<double>;
+	inline constexpr double ln2    = ln2_v<double>;
+	inline constexpr double ln10   = ln10_v<double>;
+	inline constexpr double pi     = pi_v<double>;
+	inline constexpr double sqrt2  = sqrt2_v<double>;
+	inline constexpr double sqrt3  = sqrt3_v<double>;
+
+}

BAN/include/BAN/Optional.h

@@ -13,48 +13,48 @@ namespace BAN
 	class Optional
 	{
 	public:
-		Optional();
-		Optional(Optional&&);
-		Optional(const Optional&);
-		Optional(const T&);
-		Optional(T&&);
-		template<typename... Args>
-		Optional(Args&&...);
+		constexpr Optional();
+		constexpr Optional(Optional&&);
+		constexpr Optional(const Optional&);
+		constexpr Optional(const T&);
+		constexpr Optional(T&&);
 
 		~Optional();
 
-		Optional& operator=(Optional&&);
-		Optional& operator=(const Optional&);
+		constexpr Optional& operator=(Optional&&);
+		constexpr Optional& operator=(const Optional&);
 
 		template<typename... Args>
-		Optional& emplace(Args&&...);
+		constexpr Optional& emplace(Args&&...) requires is_constructible_v<T, Args...>;
 
-		T* operator->();
-		const T* operator->() const;
+		constexpr T* operator->();
+		constexpr const T* operator->() const;
 
-		T& operator*();
-		const T& operator*() const;
+		constexpr T& operator*();
+		constexpr const T& operator*() const;
 
-		bool has_value() const;
+		constexpr bool has_value() const;
 
-		T release_value();
-		T& value();
-		const T& value() const;
+		constexpr T release_value();
+		constexpr T& value();
+		constexpr const T& value() const;
+		constexpr T& value_or(T&);
+		constexpr const T& value_or(const T&) const;
 
-		void clear();
+		constexpr void clear();
 
 	private:
-		alignas(T) uint8_t m_storage[sizeof(T)];
+		alignas(T) uint8_t m_storage[sizeof(T)] {};
 		bool m_has_value { false };
 	};
 
 	template<typename T>
-	Optional<T>::Optional()
+	constexpr Optional<T>::Optional()
 		: m_has_value(false)
 	{}
 
 	template<typename T>
-	Optional<T>::Optional(Optional<T>&& other)
+	constexpr Optional<T>::Optional(Optional<T>&& other)
 		: m_has_value(other.has_value())
 	{
 		if (other.has_value())
@@ -62,7 +62,7 @@ namespace BAN
 	}
 
 	template<typename T>
-	Optional<T>::Optional(const Optional<T>& other)
+	constexpr Optional<T>::Optional(const Optional<T>& other)
 		: m_has_value(other.has_value())
 	{
 		if (other.has_value())
@@ -70,27 +70,19 @@ namespace BAN
 	}
 
 	template<typename T>
-	Optional<T>::Optional(const T& value)
+	constexpr Optional<T>::Optional(const T& value)
 		: m_has_value(true)
 	{
 		new (m_storage) T(value);
 	}
 
 	template<typename T>
-	Optional<T>::Optional(T&& value)
+	constexpr Optional<T>::Optional(T&& value)
 		: m_has_value(true)
 	{
 		new (m_storage) T(move(value));
 	}
 
-	template<typename T>
-	template<typename... Args>
-	Optional<T>::Optional(Args&&... args)
-		: m_has_value(true)
-	{
-		new (m_storage) T(forward<Args>(args)...);
-	}
-
 	template<typename T>
 	Optional<T>::~Optional()
 	{
@@ -98,7 +90,7 @@ namespace BAN
 	}
 
 	template<typename T>
-	Optional<T>& Optional<T>::operator=(Optional&& other)
+	constexpr Optional<T>& Optional<T>::operator=(Optional&& other)
 	{
 		clear();
 		m_has_value = other.has_value();
@@ -108,18 +100,18 @@ namespace BAN
 	}
 
 	template<typename T>
-	Optional<T>& Optional<T>::operator=(const Optional& other)
+	constexpr Optional<T>& Optional<T>::operator=(const Optional& other)
 	{
 		clear();
 		m_has_value = other.has_value();
-		if (other.has_value)
+		if (other.has_value())
 			new (m_storage) T(other.value());
 		return *this;
 	}
 
 	template<typename T>
 	template<typename... Args>
-	Optional<T>& Optional<T>::emplace(Args&&... args)
+	constexpr Optional<T>& Optional<T>::emplace(Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		clear();
 		m_has_value = true;
@@ -128,41 +120,41 @@ namespace BAN
 	}
 
 	template<typename T>
-	T* Optional<T>::operator->()
+	constexpr T* Optional<T>::operator->()
 	{
 		ASSERT(has_value());
 		return &value();
 	}
 
 	template<typename T>
-	const T* Optional<T>::operator->() const
+	constexpr const T* Optional<T>::operator->() const
 	{
 		ASSERT(has_value());
 		return &value();
 	}
 
 	template<typename T>
-	T& Optional<T>::operator*()
+	constexpr T& Optional<T>::operator*()
 	{
 		ASSERT(has_value());
 		return value();
 	}
 
 	template<typename T>
-	const T& Optional<T>::operator*() const
+	constexpr const T& Optional<T>::operator*() const
 	{
 		ASSERT(has_value());
 		return value();
 	}
 
 	template<typename T>
-	bool Optional<T>::has_value() const
+	constexpr bool Optional<T>::has_value() const
 	{
 		return m_has_value;
 	}
 
 	template<typename T>
-	T Optional<T>::release_value()
+	constexpr T Optional<T>::release_value()
 	{
 		ASSERT(has_value());
 		T released_value = move(value());
@@ -172,21 +164,37 @@ namespace BAN
 	}
 
 	template<typename T>
-	T& Optional<T>::value()
+	constexpr T& Optional<T>::value()
 	{
 		ASSERT(has_value());
-		return (T&)m_storage;
+		return *reinterpret_cast<T*>(&m_storage);
 	}
 
 	template<typename T>
-	const T& Optional<T>::value() const
+	constexpr const T& Optional<T>::value() const
 	{
 		ASSERT(has_value());
-		return (const T&)m_storage;
+		return *reinterpret_cast<const T*>(&m_storage);
 	}
 
 	template<typename T>
-	void Optional<T>::clear()
+	constexpr T& Optional<T>::value_or(T& empty)
+	{
+		if (!has_value())
+			return empty;
+		return value();
+	}
+
+	template<typename T>
+	constexpr const T& Optional<T>::value_or(const T& empty) const
+	{
+		if (!has_value())
+			return empty;
+		return value();
+	}
+
+	template<typename T>
+	constexpr void Optional<T>::clear()
 	{
 		if (m_has_value)
 			value().~T();

BAN/include/BAN/PlacementNew.h

@@ -1,6 +1,10 @@
 #pragma once
 
-#include <stddef.h>
+#if __has_include(<new>)
+	#include <new>
+#else
+	#include <stddef.h>
 
-inline void* operator new(size_t, void* addr)	{ return addr; }
-inline void* operator new[](size_t, void* addr)	{ return addr; }
+	inline void* operator new(size_t, void* addr) { return addr; }
+	inline void* operator new[](size_t, void* addr) { return addr; }
+#endif

BAN/include/BAN/PriorityQueue.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "BAN/Errors.h"
+#include <BAN/Vector.h>
+#include <BAN/Heap.h>
+
+namespace BAN
+{
+
+	template<typename T, typename Comp = less<T>>
+	class PriorityQueue
+	{
+	public:
+		PriorityQueue() = default;
+		PriorityQueue(Comp comp)
+			: m_comp(comp)
+		{ }
+
+		ErrorOr<void> push(const T& value)
+		{
+			TRY(m_data.push_back(value));
+			push_heap(m_data.begin(), m_data.end());
+			return {};
+		}
+
+		ErrorOr<void> push(T&& value)
+		{
+			TRY(m_data.push_back(move(value)));
+			push_heap(m_data.begin(), m_data.end());
+			return {};
+		}
+
+		template<typename... Args>
+		ErrorOr<void> emplace(Args&&... args) requires is_constructible_v<T, Args...>
+		{
+			TRY(m_data.emplace_back(forward<Args>(args)...));
+			push_heap(m_data.begin(), m_data.end());
+			return {};
+		}
+
+		void pop()
+		{
+			pop_heap(m_data.begin(), m_data.end());
+			m_data.pop_back();
+		}
+
+		BAN::ErrorOr<void> reserve(Vector<T>::size_type size)
+		{
+			return m_data.reserve(size);
+		}
+
+		T& top() { return m_data.front(); }
+		const T& top() const { return m_data.front(); }
+
+		bool empty() const { return m_data.empty(); }
+		Vector<T>::size_type size() const { return m_data.size(); }
+		Vector<T>::size_type capacity() const { return m_data.capacity(); }
+
+	private:
+		Comp m_comp;
+		Vector<T> m_data;
+	};
+
+}

BAN/include/BAN/Queue.h

@@ -31,7 +31,7 @@ namespace BAN
 		ErrorOr<void> push(T&&);
 		ErrorOr<void> push(const T&);
 		template<typename... Args>
-		ErrorOr<void> emplace(Args&&...);
+		ErrorOr<void> emplace(Args&&...) requires is_constructible_v<T, Args...>;
 
 		ErrorOr<void> reserve(size_type);
 		ErrorOr<void> shrink_to_fit();
@@ -131,7 +131,7 @@ namespace BAN
 
 	template<typename T>
 	template<typename... Args>
-	ErrorOr<void> Queue<T>::emplace(Args&&... args)
+	ErrorOr<void> Queue<T>::emplace(Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		TRY(ensure_capacity(m_size + 1));
 		new (m_data + m_size) T(forward<Args>(args)...);

BAN/include/BAN/RefPtr.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <BAN/Atomic.h>
 #include <BAN/Errors.h>
 #include <BAN/Move.h>
 #include <BAN/NoCopyMove.h>
@@ -22,24 +23,36 @@ namespace BAN
 
 		void ref() const
 		{
-			ASSERT(m_ref_count > 0);
-			m_ref_count++;
+			uint32_t old = m_ref_count.fetch_add(1, MemoryOrder::memory_order_relaxed);
+			ASSERT(old > 0);
+		}
+
+		bool try_ref() const
+		{
+			uint32_t expected = m_ref_count.load(MemoryOrder::memory_order_relaxed);
+			for (;;)
+			{
+				if (expected == 0)
+					return false;
+				if (m_ref_count.compare_exchange(expected, expected + 1, MemoryOrder::memory_order_acquire))
+					return true;
+			}
 		}
 
 		void unref() const
 		{
-			ASSERT(m_ref_count > 0);
-			m_ref_count--;
-			if (m_ref_count == 0)
-				delete (const T*)this;
+			uint32_t old = m_ref_count.fetch_sub(1);
+			ASSERT(old > 0);
+			if (old == 1)
+				delete static_cast<const T*>(this);
 		}
 
 	protected:
 		RefCounted() = default;
-		~RefCounted() { ASSERT(m_ref_count == 0); }
+		virtual ~RefCounted() { ASSERT(m_ref_count == 0); }
 
 	private:
-		mutable uint32_t m_ref_count = 1;
+		mutable Atomic<uint32_t> m_ref_count = 1;
 	};
 
 	template<typename T>
@@ -63,8 +76,9 @@ namespace BAN
 			return ptr;
 		}
 
+		// NOTE: don't use is_constructible_v<T, Args...> as RefPtr<T> is allowed with friends
 		template<typename... Args>
-		static ErrorOr<RefPtr> create(Args&&... args)
+		static ErrorOr<RefPtr> create(Args&&... args) requires requires(Args&&... args) { T(forward<Args>(args)...); }
 		{
 			T* pointer = new T(forward<Args>(args)...);
 			if (pointer == nullptr)
@@ -124,8 +138,11 @@ namespace BAN
 		T* operator->() { return ptr(); }
 		const T* operator->() const { return ptr(); }
 
+		bool operator==(RefPtr other) const { return m_pointer == other.m_pointer; }
+		bool operator!=(RefPtr other) const { return m_pointer != other.m_pointer; }
+
 		bool empty() const { return m_pointer == nullptr; }
-		operator bool() const { return m_pointer; }
+		explicit operator bool() const { return m_pointer; }
 
 		void clear()
 		{

BAN/include/BAN/Sort.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <BAN/Heap.h>
 #include <BAN/Math.h>
 #include <BAN/Swap.h>
 #include <BAN/Traits.h>
@@ -8,7 +9,7 @@
 namespace BAN::sort
 {
 
-	template<typename It, typename Comp = less<typename It::value_type>>
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void exchange_sort(It begin, It end, Comp comp = {})
 	{
 		for (It lhs = begin; lhs != end; ++lhs)
@@ -42,7 +43,7 @@ namespace BAN::sort
 
 	}
 
-	template<typename It, typename Comp = less<typename It::value_type>>
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void quick_sort(It begin, It end, Comp comp = {})
 	{
 		if (distance(begin, end) <= 1)
@@ -52,14 +53,14 @@ namespace BAN::sort
 		quick_sort(++mid, end, comp);
 	}
 
-	template<typename It, typename Comp = less<typename It::value_type>>
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void insertion_sort(It begin, It end, Comp comp = {})
 	{
 		if (distance(begin, end) <= 1)
 			return;
 		for (It it1 = next(begin, 1); it1 != end; ++it1)
 		{
-			typename It::value_type x = move(*it1);
+			auto x = move(*it1);
 			It it2 = it1;
 			for (; it2 != begin && comp(x, *prev(it2, 1)); --it2)
 				*it2 = move(*prev(it2, 1));
@@ -67,83 +68,7 @@ namespace BAN::sort
 		}
 	}
 
-	namespace detail
-	{
-
-		template<typename It, typename Comp>
-		void push_heap(It begin, size_t hole_index, size_t top_index, typename It::value_type value, Comp comp)
-		{
-			size_t parent = (hole_index - 1) / 2;
-			while (hole_index > top_index && comp(*next(begin, parent), value))
-			{
-				*next(begin, hole_index) = move(*next(begin, parent));
-				hole_index = parent;
-				parent = (hole_index - 1) / 2;
-			}
-			*next(begin, hole_index) = move(value);
-		}
-
-		template<typename It, typename Comp>
-		void adjust_heap(It begin, size_t hole_index, size_t len, typename It::value_type value, Comp comp)
-		{
-			const size_t top_index = hole_index;
-			size_t child = hole_index;
-			while (child < (len - 1) / 2)
-			{
-				child = 2 * (child + 1);
-				if (comp(*next(begin, child), *next(begin, child - 1)))
-					child--;
-				*next(begin, hole_index) = move(*next(begin, child));
-				hole_index = child;
-			}
-			if (len % 2 == 0 && child == (len - 2) / 2)
-			{
-				child = 2 * (child + 1);
-				*next(begin, hole_index) = move(*next(begin, child - 1));
-				hole_index = child - 1;
-			}
-			push_heap(begin, hole_index, top_index, move(value), comp);
-		}
-
-	}
-
-	template<typename It, typename Comp = less<typename It::value_type>>
-	void make_heap(It begin, It end, Comp comp = {})
-	{
-		const size_t len = distance(begin, end);
-		if (len <= 1)
-			return;
-
-		size_t parent = (len - 2) / 2;
-		while (true)
-		{
-			detail::adjust_heap(begin, parent, len, move(*next(begin, parent)), comp);
-
-			if (parent == 0)
-				break;
-
-			parent--;
-		}
-	}
-
-	template<typename It, typename Comp = less<typename It::value_type>>
-	void sort_heap(It begin, It end, Comp comp = {})
-	{
-		const size_t len = distance(begin, end);
-		if (len <= 1)
-			return;
-
-		size_t last = len;
-		while (last > 1)
-		{
-			last--;
-			typename It::value_type x = move(*next(begin, last));
-			*next(begin, last) = move(*begin);
-			detail::adjust_heap(begin, 0, last, move(x), comp);
-		}
-	}
-
-	template<typename It, typename Comp = less<typename It::value_type>>
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void heap_sort(It begin, It end, Comp comp = {})
 	{
 		make_heap(begin, end, comp);
@@ -167,7 +92,7 @@ namespace BAN::sort
 
 	}
 
-	template<typename It, typename Comp = less<typename It::value_type>>
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void intro_sort(It begin, It end, Comp comp = {})
 	{
 		const size_t len = distance(begin, end);
@@ -190,10 +115,10 @@ namespace BAN::sort
 	}
 
 	template<typename It, size_t radix = 256>
-	requires is_unsigned_v<typename It::value_type> && (radix > 0 && (radix & (radix - 1)) == 0)
+	requires is_unsigned_v<it_value_type_t<It>> && (radix > 0 && (radix & (radix - 1)) == 0)
 	BAN::ErrorOr<void> radix_sort(It begin, It end)
 	{
-		using value_type = typename It::value_type;
+		using value_type = it_value_type_t<It>;
 
 		const size_t len = distance(begin, end);
 		if (len <= 1)
@@ -231,7 +156,7 @@ namespace BAN::sort
 		return {};
 	}
 
-	template<typename It, typename Comp = less<typename It::value_type>>
+	template<typename It, typename Comp = less<it_value_type_t<It>>>
 	void sort(It begin, It end, Comp comp = {})
 	{
 		return intro_sort(begin, end, comp);

BAN/include/BAN/Span.h

@@ -14,121 +14,89 @@ namespace BAN
 	public:
 		using value_type = T;
 		using size_type = size_t;
-		using iterator = IteratorSimple<T, Span>;
-		using const_iterator = ConstIteratorSimple<T, Span>;
+		using iterator = IteratorSimple<value_type, Span>;
+		using const_iterator = ConstIteratorSimple<value_type, Span>;
+
+	private:
+		template<typename S>
+		static inline constexpr bool can_init_from_v = is_same_v<value_type, const S> || is_same_v<value_type, S>;
 
 	public:
 		Span() = default;
-		Span(T*, size_type);
-		Span(Span<T>&);
+		Span(value_type* data, size_type size)
+			: m_data(data)
+			, m_size(size)
+		{ }
+
 		template<typename S>
-		requires(is_same_v<T, const S>)
-		Span(const Span<S>&);
+		Span(const Span<S>& other) requires can_init_from_v<S>
+			: m_data(other.m_data)
+			, m_size(other.m_size)
+		{ }
+		template<typename S>
+		Span(Span<S>&& other) requires can_init_from_v<S>
+			: m_data(other.m_data)
+			, m_size(other.m_size)
+		{
+			other.clear();
+		}
+
+		template<typename S>
+		Span& operator=(const Span<S>& other) requires can_init_from_v<S>
+		{
+			m_data = other.m_data;
+			m_size = other.m_size;
+			return *this;
+		}
+		template<typename S>
+		Span& operator=(Span<S>&& other) requires can_init_from_v<S>
+		{
+			m_data = other.m_data;
+			m_size = other.m_size;
+			return *this;
+		}
 
 		iterator begin() { return iterator(m_data); }
 		iterator end() { return iterator(m_data + m_size); }
 		const_iterator begin() const { return const_iterator(m_data); }
 		const_iterator end() const { return const_iterator(m_data + m_size); }
 
-		T& operator[](size_type);
-		const T& operator[](size_type) const;
+		value_type& operator[](size_type index) const
+		{
+			ASSERT(index < m_size);
+			return m_data[index];
+		}
 
-		T* data();
-		const T* data() const;
+		value_type* data() const
+		{
+			return m_data;
+		}
 
-		bool empty() const;
-		size_type size() const;
+		bool empty() const { return m_size == 0; }
+		size_type size() const { return m_size; }
 
-		void clear();
+		void clear()
+		{
+			m_data = nullptr;
+			m_size = 0;
+		}
 
-		Span slice(size_type, size_type = ~size_type(0));
+		Span slice(size_type start, size_type length = ~size_type(0)) const
+		{
+			ASSERT(start <= m_size);
+			if (length == ~size_type(0))
+				length = m_size - start;
+			ASSERT(m_size - start >= length);
+			return Span(m_data + start, length);
+		}
 
-		Span<const T> as_const() const { return Span<const T>(m_data, m_size); }
+		Span<const value_type> as_const() const { return *this; }
 
 	private:
-		T* m_data = nullptr;
+		value_type* m_data = nullptr;
 		size_type m_size = 0;
+
+		friend class Span<const value_type>;
 	};
 
-	template<typename T>
-	Span<T>::Span(T* data, size_type size)
-		: m_data(data)
-		, m_size(size)
-	{
-	}
-
-	template<typename T>
-	Span<T>::Span(Span& other)
-		: m_data(other.data())
-		, m_size(other.size())
-	{
-	}
-
-	template<typename T>
-	template<typename S>
-	requires(is_same_v<T, const S>)
-	Span<T>::Span(const Span<S>& other)
-		: m_data(other.data())
-		, m_size(other.size())
-	{
-	}
-
-	template<typename T>
-	T& Span<T>::operator[](size_type index)
-	{
-		ASSERT(m_data);
-		ASSERT(index < m_size);
-		return m_data[index];
-	}
-
-	template<typename T>
-	const T& Span<T>::operator[](size_type index) const
-	{
-		ASSERT(m_data);
-		ASSERT(index < m_size);
-		return m_data[index];
-	}
-
-	template<typename T>
-	T* Span<T>::data()
-	{
-		return m_data;
-	}
-
-	template<typename T>
-	const T* Span<T>::data() const
-	{
-		return m_data;
-	}
-
-	template<typename T>
-	bool Span<T>::empty() const
-	{
-		return m_size == 0;
-	}
-
-	template<typename T>
-	typename Span<T>::size_type Span<T>::size() const
-	{
-		return m_size;
-	}
-
-	template<typename T>
-	void Span<T>::clear()
-	{
-		m_data = nullptr;
-		m_size = 0;
-	}
-
-	template<typename T>
-	Span<T> Span<T>::slice(size_type start, size_type length)
-	{
-		ASSERT(m_data);
-		ASSERT(start <= m_size);
-		if (length == ~size_type(0))
-			length = m_size - start;
-		ASSERT(m_size - start >= length);
-		return Span(m_data + start, length);
-	}
-
 }

BAN/include/BAN/String.h

@@ -14,6 +14,7 @@ namespace BAN
 	{
 	public:
 		using size_type = size_t;
+		using value_type = char;
 		using iterator = IteratorSimple<char, String>;
 		using const_iterator = ConstIteratorSimple<char, String>;
 		static constexpr size_type sso_capacity = 15;
@@ -26,10 +27,15 @@ namespace BAN
 		~String() { clear(); }
 
 		template<typename... Args>
-		static String formatted(const char* format, const Args&... args)
+		static BAN::ErrorOr<String> formatted(const char* format, Args&&... args)
 		{
+			size_type length = 0;
+			BAN::Formatter::print([&](char) { length++; }, format, BAN::forward<Args>(args)...);
+
 			String result;
-			BAN::Formatter::print([&](char c){ MUST(result.push_back(c)); }, format, args...);
+			TRY(result.reserve(length));
+			BAN::Formatter::print([&](char c){ MUST(result.push_back(c)); }, format, BAN::forward<Args>(args)...);
+
 			return result;
 		}
 
@@ -122,7 +128,7 @@ namespace BAN
 		void remove(size_type index)
 		{
 			ASSERT(index < m_size);
-			memcpy(data() + index, data() + index + 1, m_size - index);
+			memmove(data() + index, data() + index + 1, m_size - index);
 			m_size--;
 			data()[m_size] = '\0';
 		}
@@ -347,10 +353,9 @@ namespace BAN::Formatter
 {
 
 	template<typename F>
-	void print_argument(F putc, const String& string, const ValueFormat&)
+	void print_argument(F putc, const String& string, const ValueFormat& format)
 	{
-		for (String::size_type i = 0; i < string.size(); i++)
-			putc(string[i]);
+		print_argument(putc, string.sv(), format);
 	}
 
 }

BAN/include/BAN/StringView.h

@@ -2,6 +2,7 @@
 
 #include <BAN/Formatter.h>
 #include <BAN/ForwardList.h>
+#include <BAN/Hash.h>
 #include <BAN/Iterators.h>
 #include <BAN/Optional.h>
 #include <BAN/Vector.h>
@@ -13,43 +14,49 @@ namespace BAN
 	{
 	public:
 		using size_type = size_t;
+		using value_type = char;
 		using const_iterator = ConstIteratorSimple<char, StringView>;
 
 	public:
-		StringView() {}
-		StringView(const String&);
-		StringView(const char* string, size_type len = -1)
+		constexpr StringView() {}
+		constexpr StringView(const char* string, size_type len = -1)
 		{
 			if (len == size_type(-1))
-				len = strlen(string);
+				for (len = 0; string[len];)
+					len++;
 			m_data = string;
 			m_size = len;
 		}
+		StringView(const String&);
 
-		const_iterator begin() const { return const_iterator(m_data); }
-		const_iterator end() const { return const_iterator(m_data + m_size); }
+		constexpr const_iterator begin() const { return const_iterator(m_data); }
+		constexpr const_iterator end() const { return const_iterator(m_data + m_size); }
 
-		char operator[](size_type index) const
+		constexpr char operator[](size_type index) const
 		{
 			ASSERT(index < m_size);
 			return m_data[index];
 		}
 
-		bool operator==(StringView other) const
+		constexpr bool operator==(StringView other) const
 		{
 			if (m_size != other.m_size)
 				return false;
-			return memcmp(m_data, other.m_data, m_size) == 0;
+			for (size_type i = 0; i < m_size; i++)
+				if (m_data[i] != other.m_data[i])
+					return false;
+			return true;
 		}
 
-		bool operator==(const char* other) const
+		constexpr bool operator==(const char* other) const
 		{
-			if (memcmp(m_data, other, m_size))
-				return false;
+			for (size_type i = 0; i < m_size; i++)
+				if (m_data[i] != other[i])
+					return false;
 			return other[m_size] == '\0';
 		}
 
-		StringView substring(size_type index, size_type len = -1) const
+		constexpr StringView substring(size_type index, size_type len = -1) const
 		{
 			ASSERT(index <= m_size);
 			if (len == size_type(-1))
@@ -133,13 +140,13 @@ namespace BAN
 			return result;
 		}
 
-		char back() const
+		constexpr char back() const
 		{
 			ASSERT(m_size > 0);
 			return m_data[m_size - 1];
 		}
 
-		char front() const
+		constexpr char front() const
 		{
 			ASSERT(m_size > 0);
 			return m_data[0];
@@ -161,7 +168,33 @@ namespace BAN
 			return {};
 		}
 
-		bool contains(char ch) const
+		BAN::Optional<size_type> rfind(char ch) const
+		{
+			for (size_type i = m_size; i > 0; i--)
+				if (m_data[i - 1] == ch)
+					return i - 1;
+			return {};
+		}
+
+		BAN::Optional<size_type> rfind(bool(*comp)(char)) const
+		{
+			for (size_type i = m_size; i > 0; i--)
+				if (comp(m_data[i - 1]))
+					return i - 1;
+			return {};
+		}
+
+		constexpr bool starts_with(BAN::StringView target) const
+		{
+			if (target.size() > m_size)
+				return false;
+			for (size_type i = 0; i < target.size(); i++)
+				if (m_data[i] != target[i])
+					return false;
+			return true;
+		}
+
+		constexpr bool contains(char ch) const
 		{
 			for (size_type i = 0; i < m_size; i++)
 				if (m_data[i] == ch)
@@ -169,7 +202,7 @@ namespace BAN
 			return false;
 		}
 
-		size_type count(char ch) const
+		constexpr size_type count(char ch) const
 		{
 			size_type result = 0;
 			for (size_type i = 0; i < m_size; i++)
@@ -178,27 +211,48 @@ namespace BAN
 			return result;
 		}
 
-		bool empty() const { return m_size == 0; }
-		size_type size() const { return m_size; }
-		const char* data() const { return m_data; }
+		constexpr bool empty() const { return m_size == 0; }
+		constexpr size_type size() const { return m_size; }
+		constexpr const char* data() const { return m_data; }
 
 	private:
 		const char*	m_data = nullptr;
 		size_type	m_size = 0;
 	};
 
+	template<>
+	struct hash<StringView>
+	{
+		hash_t operator()(StringView string) const
+		{
+			constexpr hash_t FNV_offset_basis = 0x811c9dc5;
+			constexpr hash_t FNV_prime = 0x01000193;
+
+			hash_t hash = FNV_offset_basis;
+			for (StringView::size_type i = 0; i < string.size(); i++)
+			{
+				hash *= FNV_prime;
+				hash ^= (uint8_t)string[i];
+			}
+
+			return hash;
+		}
+	};
+
 }
 
-inline BAN::StringView operator""sv(const char* str, BAN::StringView::size_type len) { return BAN::StringView(str, len); }
+inline constexpr BAN::StringView operator""_sv(const char* str, BAN::StringView::size_type len) { return BAN::StringView(str, len); }
 
 namespace BAN::Formatter
 {
 
 	template<typename F>
-	void print_argument(F putc, const StringView& sv, const ValueFormat&)
+	void print_argument(F putc, const StringView& sv, const ValueFormat& format)
 	{
 		for (StringView::size_type i = 0; i < sv.size(); i++)
 			putc(sv[i]);
+		for (int i = sv.size(); i < format.fill; i++)
+			putc(' ');
 	}
 
 }

BAN/include/BAN/Traits.h

@@ -3,10 +3,10 @@
 namespace BAN
 {
 
-	template<typename T> struct remove_refenrece { using type = T; };
-	template<typename T> struct remove_refenrece<T&> { using type =  T; };
-	template<typename T> struct remove_refenrece<T&&> { using type = T; };
-	template<typename T> using remove_reference_t = typename remove_refenrece<T>::type;
+	template<typename T> struct remove_reference { using type = T; };
+	template<typename T> struct remove_reference<T&> { using type =  T; };
+	template<typename T> struct remove_reference<T&&> { using type = T; };
+	template<typename T> using remove_reference_t = typename remove_reference<T>::type;
 
 	template<typename T> struct remove_const { using type = T; };
 	template<typename T> struct remove_const<const T> { using type = T; };
@@ -34,12 +34,15 @@ namespace BAN
 	template<typename T1, typename T2> struct either_or<true, T1, T2> { using type = T1; };
 	template<bool B, typename T1, typename T2> using either_or_t = typename either_or<B, T1, T2>::type;
 
-	struct true_type { static constexpr bool value = true; };
-	struct false_type { static constexpr bool value = false; };
+	template<typename T, T V> struct integral_constant { static constexpr T value = V; };
+	template<typename T, T V > inline constexpr T integral_constant_v = integral_constant<T, V>::value;
+	using true_type = integral_constant<bool, true>;
+	using false_type = integral_constant<bool, false>;
 
 	template<typename T, typename S>	struct is_same			: false_type {};
 	template<typename T>				struct is_same<T, T>	: true_type {};
 	template<typename T, typename S> inline constexpr bool is_same_v = is_same<T, S>::value;
+	template<typename T, typename S> concept same_as = BAN::is_same_v<T, S>;
 
 	template<typename T> struct is_lvalue_reference		: false_type {};
 	template<typename T> struct is_lvalue_reference<T&>	: true_type {};
@@ -58,6 +61,9 @@ namespace BAN
 	template<typename T> struct is_move_constructible { static constexpr bool value = is_constructible_v<T, T&&>; };
 	template<typename T> inline constexpr bool is_move_constructible_v = is_move_constructible<T>::value;
 
+	template<typename T> struct is_trivially_copyable { static constexpr bool value = __is_trivially_copyable(T); };
+	template<typename T> inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
+
 	template<typename T> struct is_integral { static constexpr bool value = requires (T t, T* p, void (*f)(T)) { reinterpret_cast<T>(t); f(0); p + t; }; };
 	template<typename T> inline constexpr bool is_integral_v = is_integral<T>::value;
 	template<typename T> concept integral = is_integral_v<T>;
@@ -87,8 +93,8 @@ namespace BAN
 	template<typename Base, typename Derived> struct is_base_of { static constexpr bool value = __is_base_of(Base, Derived); };
 	template<typename Base, typename Derived> inline constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
 
-	template<typename T, T V> struct integral_constant { static constexpr T value = V; };
-	template<typename T, T V > inline constexpr T integral_constant_v = integral_constant<T, V>::value;
+	template<typename T> struct is_pod { static constexpr bool value = __is_pod(T); };
+	template<typename T> inline constexpr bool is_pod_v = is_pod<T>::value;
 
 	namespace detail
 	{
@@ -136,6 +142,10 @@ namespace BAN
 	template<typename T> using make_signed_t = typename make_signed<T>::type;
 #undef __BAN_TRAITS_MAKE_SIGNED_CV
 
+	template<typename T> struct it_value_type { using value_type = T::value_type; };
+	template<typename T> struct it_value_type<T*> { using value_type = T; };
+	template<typename T> using it_value_type_t = typename it_value_type<T>::value_type;
+
 	template<typename T> struct less	{ constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs < rhs; } };
 	template<typename T> struct equal	{ constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs == rhs; } };
 	template<typename T> struct greater	{ constexpr bool operator()(const T& lhs, const T& rhs) const { return lhs > rhs; } };

BAN/include/BAN/UTF8.h

@@ -18,23 +18,24 @@ namespace BAN::UTF8
 			return 3;
 		if ((first_byte & 0xF8) == 0xF0)
 			return 4;
-		return 0;
+		return UTF8::invalid;
 	}
 
-	constexpr uint32_t to_codepoint(uint8_t* bytes)
+	template<typename T> requires (sizeof(T) == 1)
+	constexpr uint32_t to_codepoint(const T* bytes)
 	{
 		uint32_t length = byte_length(bytes[0]);
 
 		for (uint32_t i = 1; i < length; i++)
-			if ((bytes[i] & 0xC0) != 0x80)
+			if (((uint8_t)bytes[i] & 0xC0) != 0x80)
 				return UTF8::invalid;
 
 		switch (length)
 		{
-			case 1: return ((bytes[0] & 0x80) != 0x00) ? UTF8::invalid :   bytes[0];
-			case 2: return ((bytes[0] & 0xE0) != 0xC0) ? UTF8::invalid : ((bytes[0] & 0x1F) <<  6) |  (bytes[1] & 0x3F);
-			case 3: return ((bytes[0] & 0xF0) != 0xE0) ? UTF8::invalid : ((bytes[0] & 0x0F) << 12) | ((bytes[1] & 0x3F) <<  6) |  (bytes[2] & 0x3F);
-			case 4: return ((bytes[0] & 0xF8) != 0xF0) ? UTF8::invalid : ((bytes[0] & 0x07) << 18) | ((bytes[1] & 0x3F) << 12) | ((bytes[2] & 0x3F) << 6) | (bytes[3] & 0x3F);
+			case 1: return (((uint8_t)bytes[0] & 0x80) != 0x00) ? UTF8::invalid :   (uint8_t)bytes[0];
+			case 2: return (((uint8_t)bytes[0] & 0xE0) != 0xC0) ? UTF8::invalid : (((uint8_t)bytes[0] & 0x1F) <<  6) |  ((uint8_t)bytes[1] & 0x3F);
+			case 3: return (((uint8_t)bytes[0] & 0xF0) != 0xE0) ? UTF8::invalid : (((uint8_t)bytes[0] & 0x0F) << 12) | (((uint8_t)bytes[1] & 0x3F) <<  6) |  ((uint8_t)bytes[2] & 0x3F);
+			case 4: return (((uint8_t)bytes[0] & 0xF8) != 0xF0) ? UTF8::invalid : (((uint8_t)bytes[0] & 0x07) << 18) | (((uint8_t)bytes[1] & 0x3F) << 12) | (((uint8_t)bytes[2] & 0x3F) << 6) | ((uint8_t)bytes[3] & 0x3F);
 		}
 
 		return UTF8::invalid;
@@ -75,6 +76,8 @@ namespace BAN::UTF8
 			}
 		}
 
+		*ptr = '\0';
+
 		return true;
 	}
 

BAN/include/BAN/UniqPtr.h

@@ -33,8 +33,9 @@ namespace BAN
 			return uniq;
 		}
 
+		// NOTE: don't use is_constructible_v<T, Args...> as UniqPtr<T> is allowed with friends
 		template<typename... Args>
-		static BAN::ErrorOr<UniqPtr> create(Args&&... args)
+		static BAN::ErrorOr<UniqPtr> create(Args&&... args) requires requires(Args&&... args) { T(forward<Args>(args)...); }
 		{
 			UniqPtr uniq;
 			uniq.m_pointer = new T(BAN::forward<Args>(args)...);

BAN/include/BAN/Variant.h

@@ -126,14 +126,16 @@ namespace BAN
 		Variant(Variant&& other)
 			: m_index(other.m_index)
 		{
-			detail::move_construct<Ts...>(other.m_index, other.m_storage, m_storage);
+			if (other.has_value())
+				detail::move_construct<Ts...>(other.m_index, other.m_storage, m_storage);
 			other.clear();
 		}
 
 		Variant(const Variant& other)
 			: m_index(other.m_index)
 		{
-			detail::copy_construct<Ts...>(other.m_index, other.m_storage, m_storage);
+			if (other.has_value())
+				detail::copy_construct<Ts...>(other.m_index, other.m_storage, m_storage);
 		}
 
 		template<typename T>
@@ -157,12 +159,13 @@ namespace BAN
 
 		Variant& operator=(Variant&& other)
 		{
-			if (m_index == other.m_index)
+			if (m_index == other.m_index && m_index != invalid_index())
 				detail::move_assign<Ts...>(m_index, other.m_storage, m_storage);
 			else
 			{
 				clear();
-				detail::move_construct<Ts...>(other.m_index, other.m_storage, m_storage);
+				if (other.has_value())
+					detail::move_construct<Ts...>(other.m_index, other.m_storage, m_storage);
 				m_index = other.m_index;
 			}
 			other.clear();
@@ -171,12 +174,13 @@ namespace BAN
 
 		Variant& operator=(const Variant& other)
 		{
-			if (m_index == other.m_index)
+			if (m_index == other.m_index && m_index != invalid_index())
 				detail::copy_assign<Ts...>(m_index, other.m_storage, m_storage);
 			else
 			{
 				clear();
-				detail::copy_construct<Ts...>(other.m_index, other.m_storage, m_storage);
+				if (other.has_value())
+					detail::copy_construct<Ts...>(other.m_index, other.m_storage, m_storage);
 				m_index = other.m_index;
 			}
 			return *this;
@@ -217,7 +221,7 @@ namespace BAN
 		}
 
 		template<typename T, typename... Args>
-		void emplace(Args&&... args) requires (can_have<T>())
+		void emplace(Args&&... args) requires (can_have<T>() && is_constructible_v<T, Args...>)
 		{
 			clear();
 			m_index = detail::index<T, Ts...>();
@@ -286,6 +290,16 @@ namespace BAN
 			return **reinterpret_cast<const remove_reference_t<T>**>(m_storage);
 		}
 
+		bool has_value() const
+		{
+			return m_index != invalid_index();
+		}
+
+		explicit operator bool() const
+		{
+			return has_value();
+		}
+
 		void clear()
 		{
 			if (m_index != invalid_index())

BAN/include/BAN/Vector.h

@@ -7,6 +7,7 @@
 #include <BAN/New.h>
 #include <BAN/PlacementNew.h>
 #include <BAN/Span.h>
+#include <BAN/Swap.h>
 
 namespace BAN
 {
@@ -34,9 +35,9 @@ namespace BAN
 		ErrorOr<void> push_back(T&&);
 		ErrorOr<void> push_back(const T&);
 		template<typename... Args>
-		ErrorOr<void> emplace_back(Args&&...);
+		ErrorOr<void> emplace_back(Args&&...) requires is_constructible_v<T, Args...>;
 		template<typename... Args>
-		ErrorOr<void> emplace(size_type, Args&&...);
+		ErrorOr<void> emplace(size_type, Args&&...) requires is_constructible_v<T, Args...>;
 		ErrorOr<void> insert(size_type, T&&);
 		ErrorOr<void> insert(size_type, const T&);
 
@@ -55,7 +56,7 @@ namespace BAN
 		bool contains(const T&) const;
 
 		Span<T> span() { return Span(m_data, m_size); }
-		const Span<T> span() const { return Span(m_data, m_size); }
+		Span<const T> span() const { return Span(m_data, m_size); }
 
 		const T& operator[](size_type) const;
 		T& operator[](size_type);
@@ -65,6 +66,8 @@ namespace BAN
 		const T& front() const;
 		T& front();
 
+		void reverse();
+
 		ErrorOr<void> resize(size_type)				requires is_default_constructible_v<T>;
 		ErrorOr<void> resize(size_type, const T&)	requires is_copy_constructible_v<T>;
 		ErrorOr<void> reserve(size_type);
@@ -138,10 +141,13 @@ namespace BAN
 	template<typename T>
 	Vector<T>& Vector<T>::operator=(const Vector<T>& other)
 	{
-		clear();
 		MUST(ensure_capacity(other.size()));
-		for (size_type i = 0; i < other.size(); i++)
+		for (size_type i = 0; i < BAN::Math::min(size(), other.size()); i++)
+			m_data[i] = other.m_data[i];
+		for (size_type i = size(); i < other.size(); i++)
 			new (m_data + i) T(other[i]);
+		for (size_type i = other.size(); i < size(); i++)
+			m_data[i].~T();
 		m_size = other.m_size;
 		return *this;
 	}
@@ -163,7 +169,7 @@ namespace BAN
 
 	template<typename T>
 	template<typename... Args>
-	ErrorOr<void> Vector<T>::emplace_back(Args&&... args)
+	ErrorOr<void> Vector<T>::emplace_back(Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		TRY(ensure_capacity(m_size + 1));
 		new (m_data + m_size) T(forward<Args>(args)...);
@@ -173,7 +179,7 @@ namespace BAN
 
 	template<typename T>
 	template<typename... Args>
-	ErrorOr<void> Vector<T>::emplace(size_type index, Args&&... args)
+	ErrorOr<void> Vector<T>::emplace(size_type index, Args&&... args) requires is_constructible_v<T, Args...>
 	{
 		ASSERT(index <= m_size);
 		TRY(ensure_capacity(m_size + 1));
@@ -298,6 +304,13 @@ namespace BAN
 		return m_data[0];
 	}
 
+	template<typename T>
+	void Vector<T>::reverse()
+	{
+		for (size_type i = 0; i < m_size / 2; i++)
+			BAN::swap(m_data[i], m_data[m_size - i - 1]);
+	}
+
 	template<typename T>
 	ErrorOr<void> Vector<T>::resize(size_type size) requires is_default_constructible_v<T>
 	{
@@ -368,19 +381,46 @@ namespace BAN
 	template<typename T>
 	ErrorOr<void> Vector<T>::ensure_capacity(size_type size)
 	{
+		static_assert(alignof(T) <= alignof(max_align_t), "over aligned types not supported");
+
 		if (m_capacity >= size)
 			return {};
-		size_type new_cap = BAN::Math::max<size_type>(size, m_capacity * 2);
-		T* new_data = (T*)BAN::allocator(new_cap * sizeof(T));
-		if (new_data == nullptr)
-			return Error::from_errno(ENOMEM);
-		for (size_type i = 0; i < m_size; i++)
+
+		const size_type new_cap = BAN::Math::max<size_type>(size, m_capacity * 2);
+
+		if constexpr (BAN::is_trivially_copyable_v<T>)
 		{
-			new (new_data + i) T(move(m_data[i]));
-			m_data[i].~T();
+			if constexpr (BAN::reallocator)
+			{
+				auto* new_data = static_cast<T*>(BAN::reallocator(m_data, new_cap * sizeof(T)));
+				if (new_data == nullptr)
+					return Error::from_errno(ENOMEM);
+				m_data = new_data;
+			}
+			else
+			{
+				auto* new_data = static_cast<T*>(BAN::allocator(new_cap * sizeof(T)));
+				if (new_data == nullptr)
+					return Error::from_errno(ENOMEM);
+				memcpy(new_data, m_data, m_size * sizeof(T));
+				BAN::deallocator(m_data);
+				m_data = new_data;
+			}
 		}
-		BAN::deallocator(m_data);
-		m_data = new_data;
+		else
+		{
+			auto* new_data = static_cast<T*>(BAN::allocator(new_cap * sizeof(T)));
+			if (new_data == nullptr)
+				return Error::from_errno(ENOMEM);
+			for (size_type i = 0; i < m_size; i++)
+			{
+				new (new_data + i) T(move(m_data[i]));
+				m_data[i].~T();
+			}
+			BAN::deallocator(m_data);
+			m_data = new_data;
+		}
+
 		m_capacity = new_cap;
 		return {};
 	}

BAN/include/BAN/WeakPtr.h

@@ -2,6 +2,10 @@
 
 #include <BAN/RefPtr.h>
 
+#if __is_kernel
+#include <kernel/Lock/SpinLock.h>
+#endif
+
 namespace BAN
 {
 
@@ -11,22 +15,37 @@ namespace BAN
 	template<typename T>
 	class WeakPtr;
 
+	// FIXME: Write this without using locks...
 	template<typename T>
 	class WeakLink : public RefCounted<WeakLink<T>>
 	{
 	public:
-		RefPtr<T> lock() { ASSERT(m_ptr); return raw_ptr(); }
-		T* raw_ptr() { return m_ptr; }
-
+		RefPtr<T> try_lock() const
+		{
+#if __is_kernel
+			Kernel::SpinLockGuard _(m_weak_lock);
+#endif
+			if (m_ptr && m_ptr->try_ref())
+				return RefPtr<T>::adopt(m_ptr);
+			return nullptr;
+		}
 		bool valid() const { return m_ptr; }
-		void invalidate() { m_ptr = nullptr; }
+		void invalidate()
+		{
+#if __is_kernel
+			Kernel::SpinLockGuard _(m_weak_lock);
+#endif
+			m_ptr = nullptr;
+		}
 
 	private:
 		WeakLink(T* ptr) : m_ptr(ptr) {}
 
 	private:
 		T* m_ptr;
-
+#if __is_kernel
+		mutable Kernel::SpinLock m_weak_lock;
+#endif
 		friend class RefPtr<WeakLink<T>>;
 	};
 
@@ -34,7 +53,7 @@ namespace BAN
 	class Weakable
 	{
 	public:
-		~Weakable()
+		virtual ~Weakable()
 		{
 			if (m_link)
 				m_link->invalidate();
@@ -80,10 +99,10 @@ namespace BAN
 			return *this;
 		}
 
-		RefPtr<T> lock()
+		RefPtr<T> lock() const
 		{
-			if (m_link->valid())
-				return m_link->lock();
+			if (m_link)
+				return m_link->try_lock();
 			return nullptr;
 		}
 
@@ -91,7 +110,7 @@ namespace BAN
 
 		bool valid() const { return m_link && m_link->valid(); }
 
-		operator bool() const { return valid(); }
+		explicit operator bool() const { return valid(); }
 
 	private:
 		WeakPtr(const RefPtr<WeakLink<T>>& link)

CMakeLists.txt

@@ -4,46 +4,51 @@ if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "banan-os")
 	message(FATAL_ERROR "CMAKE_SYSTEM_NAME is not banan-os")
 endif ()
 
-#add_compile_options(-mno-sse -mno-sse2)
-add_compile_definitions(__enable_sse=1)
-
 project(banan-os CXX C ASM)
 
-set(BANAN_BASE_SYSROOT ${CMAKE_SOURCE_DIR}/base-sysroot.tar.gz)
 set(BANAN_INCLUDE ${BANAN_SYSROOT}/usr/include)
-set(BANAN_LIB ${BANAN_SYSROOT}/usr/lib)
-set(BANAN_BIN ${BANAN_SYSROOT}/usr/bin)
-set(BANAN_SHARE ${BANAN_SYSROOT}/usr/share)
-set(BANAN_BOOT ${BANAN_SYSROOT}/boot)
+set(BANAN_LIB     ${BANAN_SYSROOT}/usr/lib)
+set(BANAN_BIN     ${BANAN_SYSROOT}/usr/bin)
+set(BANAN_ETC     ${BANAN_SYSROOT}/usr/etc)
+set(BANAN_SHARE   ${BANAN_SYSROOT}/usr/share)
+set(BANAN_BOOT    ${BANAN_SYSROOT}/boot)
+
+set(CMAKE_INSTALL_BINDIR     ${BANAN_BIN})
+set(CMAKE_INSTALL_SBINDIR    ${BANAN_BIN})
+set(CMAKE_INSTALL_LIBDIR     ${BANAN_LIB})
+set(CMAKE_INSTALL_INCLUDEDIR ${BANAN_INCLUDE})
+set(CMAKE_INSTALL_SYSCONF    ${BANAN_ETC})
+set(CMAKE_INSTALL_MESSAGE    NEVER)
+set(CMAKE_SKIP_INSTALL_ALL_DEPENDENCY True)
+
+set(CMAKE_STATIC_LIBRARY_PREFIX "")
+set(CMAKE_SHARED_LIBRARY_PREFIX "")
+set(BUILD_SHARED_LIBS True)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# include headers of ${library} to ${target}
+function(banan_include_headers target library)
+	target_include_directories(${target} PUBLIC $<TARGET_PROPERTY:${library},SOURCE_DIR>/include)
+endfunction()
+
+# include headers and link ${library} to ${target}
+function(banan_link_library target library)
+	target_link_libraries(${target} PUBLIC ${library})
+	banan_include_headers(${target} ${library})
+endfunction()
+
+# add install step for all header files of target
+function(banan_install_headers target)
+	file(GLOB_RECURSE headers RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/include *.h)
+	foreach(header ${headers})
+		get_filename_component(subdirectory ${header} DIRECTORY)
+		install(FILES include/${header} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${subdirectory})
+	endforeach()
+	target_include_directories(${target} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+endfunction()
 
 add_subdirectory(kernel)
 add_subdirectory(bootloader)
 add_subdirectory(BAN)
-add_subdirectory(libc)
-add_subdirectory(LibELF)
 add_subdirectory(userspace)
-
-add_custom_target(sysroot
-	COMMAND ${CMAKE_COMMAND} -E make_directory ${BANAN_SYSROOT}
-	COMMAND cd ${BANAN_SYSROOT} && tar xf ${BANAN_BASE_SYSROOT}
-)
-
-add_custom_target(headers
-	DEPENDS kernel-headers
-	DEPENDS ban-headers
-	DEPENDS libc-headers
-	DEPENDS libelf-headers
-)
-
-add_custom_target(install-sysroot
-	DEPENDS kernel-install
-	DEPENDS ban-install
-	DEPENDS libc-install
-	DEPENDS userspace-install
-	DEPENDS libelf-install
-)
-
-add_custom_target(package-sysroot
-	COMMAND cd ${BANAN_SYSROOT} && tar cf ${BANAN_SYSROOT_TAR} *
-	DEPENDS install-sysroot
-)

LibELF/CMakeLists.txt

@@ -1,12 +0,0 @@
-cmake_minimum_required(VERSION 3.26)
-
-project(LibELF CXX)
-
-add_custom_target(libelf-headers
-	COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/include/ ${BANAN_INCLUDE}/
-	DEPENDS sysroot
-)
-
-add_custom_target(libelf-install
-	DEPENDS libelf-headers
-)

LibELF/LibELF/ELF.cpp

@@ -1,405 +0,0 @@
-#include <BAN/ScopeGuard.h>
-#include <LibELF/ELF.h>
-#include <LibELF/Values.h>
-
-#ifdef __is_kernel
-#include <kernel/FS/VirtualFileSystem.h>
-#include <kernel/Process.h>
-#endif
-
-#include <fcntl.h>
-
-#define ELF_PRINT_HEADERS 0
-
-#ifdef __is_kernel
-extern uint8_t g_kernel_end[];
-using namespace Kernel;
-#endif
-
-namespace LibELF
-{
-
-#ifdef __is_kernel
-	BAN::ErrorOr<BAN::UniqPtr<ELF>> ELF::load_from_file(BAN::RefPtr<Inode> inode)
-	{
-		BAN::Vector<uint8_t> buffer;
-		TRY(buffer.resize(inode->size()));
-
-		TRY(inode->read(0, buffer.data(), inode->size()));
-
-		ELF* elf_ptr = new ELF(BAN::move(buffer));
-		if (elf_ptr == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
-
-		auto elf = BAN::UniqPtr<ELF>::adopt(elf_ptr);
-		TRY(elf->load());
-
-		return BAN::move(elf);
-	}
-#else
-	BAN::ErrorOr<ELF*> ELF::load_from_file(BAN::StringView file_path)
-	{
-		ELF* elf = nullptr;
-
-		{
-			BAN::Vector<uint8_t> data;
-
-			int fd = TRY(Kernel::Process::current().open(file_path, O_RDONLY));
-			BAN::ScopeGuard _([fd] { MUST(Kernel::Process::current().close(fd)); });
-
-			struct stat st;
-			TRY(Kernel::Process::current().fstat(fd, &st));
-
-			TRY(data.resize(st.st_size));
-
-			TRY(Kernel::Process::current().read(fd, data.data(), data.size()));
-
-			elf = new ELF(BAN::move(data));
-			ASSERT(elf);
-		}
-
-		if (auto res = elf->load(); res.is_error())
-		{
-			delete elf;
-			return res.error();
-		}
-
-		return elf;
-	}
-#endif
-
-	BAN::ErrorOr<void> ELF::load()
-	{
-		if (m_data.size() < EI_NIDENT)
-		{
-			dprintln("Too small ELF file");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_data[EI_MAG0] != ELFMAG0 ||
-			m_data[EI_MAG1] != ELFMAG1 ||
-			m_data[EI_MAG2] != ELFMAG2 ||
-			m_data[EI_MAG3] != ELFMAG3)
-		{
-			dprintln("Invalid ELF header");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_data[EI_DATA] != ELFDATA2LSB)
-		{
-			dprintln("Only little-endian is supported");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_data[EI_VERSION] != EV_CURRENT)
-		{
-			dprintln("Invalid ELF version");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_data[EI_CLASS] == ELFCLASS64)
-		{
-			if (m_data.size() <= sizeof(Elf64FileHeader))
-			{
-				dprintln("Too small ELF file");
-				return BAN::Error::from_errno(EINVAL);
-			}
-
-			auto& header = file_header64();
-			if (!parse_elf64_file_header(header))
-				return BAN::Error::from_errno(EINVAL);
-
-			for (size_t i = 0; i < header.e_phnum; i++)
-			{
-				auto& program_header = program_header64(i);
-				if (!parse_elf64_program_header(program_header))
-					return BAN::Error::from_errno(EINVAL);
-			}
-
-			for (size_t i = 1; i < header.e_shnum; i++)
-			{
-				auto& section_header = section_header64(i);
-				if (!parse_elf64_section_header(section_header))
-					return BAN::Error::from_errno(EINVAL);
-			}
-		}
-		else if (m_data[EI_CLASS] == ELFCLASS32)
-		{
-			if (m_data.size() <= sizeof(Elf32FileHeader))
-			{
-				dprintln("Too small ELF file");
-				return BAN::Error::from_errno(EINVAL);
-			}
-
-			auto& header = file_header32();
-			if (!parse_elf32_file_header(header))
-				return BAN::Error::from_errno(EINVAL);
-
-			for (size_t i = 0; i < header.e_phnum; i++)
-			{
-				auto& program_header = program_header32(i);
-				if (!parse_elf32_program_header(program_header))
-					return BAN::Error::from_errno(EINVAL);
-			}
-
-			for (size_t i = 1; i < header.e_shnum; i++)
-			{
-				auto& section_header = section_header32(i);
-				if (!parse_elf32_section_header(section_header))
-					return BAN::Error::from_errno(EINVAL);
-			}
-		}
-
-		return {};
-	}
-
-	bool ELF::is_x86_32() const { return m_data[EI_CLASS] == ELFCLASS32; }
-	bool ELF::is_x86_64() const { return m_data[EI_CLASS] == ELFCLASS64; }
-
-	/*
-
-		64 bit ELF
-
-	*/
-
-	const char* ELF::lookup_section_name64(uint32_t offset) const
-	{
-		return lookup_string64(file_header64().e_shstrndx, offset);
-	}
-
-	const char* ELF::lookup_string64(size_t table_index, uint32_t offset) const
-	{
-		if (table_index == SHN_UNDEF)
-			return nullptr;
-		auto& section_header = section_header64(table_index);
-		return (const char*)m_data.data() + section_header.sh_offset + offset;
-	}
-
-	bool ELF::parse_elf64_file_header(const Elf64FileHeader& header)
-	{
-		if (header.e_type != ET_EXEC)
-		{
-			dprintln("Only executable files are supported");
-			return false;
-		}
-
-		if (header.e_version != EV_CURRENT)
-		{
-			dprintln("Invalid ELF version");
-			return false;
-		}
-
-		return true;
-	}
-
-	bool ELF::parse_elf64_program_header(const Elf64ProgramHeader& header)
-	{
-#if ELF_PRINT_HEADERS
-		dprintln("program header");
-		dprintln("  type   {H}", header.p_type);
-		dprintln("  flags  {H}", header.p_flags);
-		dprintln("  offset {H}", header.p_offset);
-		dprintln("  vaddr  {H}", header.p_vaddr);
-		dprintln("  paddr  {H}", header.p_paddr);
-		dprintln("  filesz {}", header.p_filesz);
-		dprintln("  memsz  {}", header.p_memsz);
-		dprintln("  align  {}", header.p_align);
-#endif
-		(void)header;
-		return true;
-	}
-
-	bool ELF::parse_elf64_section_header(const Elf64SectionHeader& header)
-	{
-#if ELF_PRINT_HEADERS
-		if (auto* name = lookup_section_name64(header.sh_name))
-			dprintln("{}", name);
-
-		switch (header.sh_type)
-		{
-			case SHT_NULL:
-				dprintln("  SHT_NULL");
-				break;
-			case SHT_PROGBITS:
-				dprintln("  SHT_PROGBITS");
-				break;
-			case SHT_SYMTAB:
-				for (size_t i = 1; i < header.sh_size / header.sh_entsize; i++)
-				{
-					auto& symbol = ((const Elf64Symbol*)(m_data.data() + header.sh_offset))[i];
-					if (auto* name = lookup_string64(header.sh_link, symbol.st_name))
-						dprintln("  {}", name);
-				}
-				break;
-			case SHT_STRTAB:
-				dprintln("  SHT_STRTAB");
-				break;
-			case SHT_RELA:
-				dprintln("  SHT_RELA");
-				break;
-			case SHT_NOBITS:
-				dprintln("  SHT_NOBITS");
-				break;
-			case SHT_REL:
-				dprintln("  SHT_REL");
-				break;
-			case SHT_SHLIB:
-				dprintln("  SHT_SHLIB");
-				break;
-			case SHT_DYNSYM:
-				dprintln("  SHT_DYNSYM");
-				break;
-			default:
-				ASSERT(false);
-		}
-#endif
-		(void)header;
-		return true;
-	}
-
-	const Elf64FileHeader& ELF::file_header64() const
-	{
-		ASSERT(is_x86_64());
-		return *(const Elf64FileHeader*)m_data.data();
-	}
-
-	const Elf64ProgramHeader& ELF::program_header64(size_t index) const
-	{
-		ASSERT(is_x86_64());
-		const auto& file_header = file_header64();
-		ASSERT(index < file_header.e_phnum);
-		return *(const Elf64ProgramHeader*)(m_data.data() + file_header.e_phoff + file_header.e_phentsize * index);
-	}
-
-	const Elf64SectionHeader& ELF::section_header64(size_t index) const
-	{
-		ASSERT(is_x86_64());
-		const auto& file_header = file_header64();
-		ASSERT(index < file_header.e_shnum);
-		return *(const Elf64SectionHeader*)(m_data.data() + file_header.e_shoff + file_header.e_shentsize * index);
-	}
-
-	/*
-
-		32 bit ELF
-
-	*/
-
-	const char* ELF::lookup_section_name32(uint32_t offset) const
-	{
-		return lookup_string32(file_header32().e_shstrndx, offset);
-	}
-
-	const char* ELF::lookup_string32(size_t table_index, uint32_t offset) const
-	{
-		if (table_index == SHN_UNDEF)
-			return nullptr;
-		auto& section_header = section_header32(table_index);
-		return (const char*)m_data.data() + section_header.sh_offset + offset;
-	}
-
-	bool ELF::parse_elf32_file_header(const Elf32FileHeader& header)
-	{
-		if (header.e_type != ET_EXEC)
-		{
-			dprintln("Only executable files are supported");
-			return false;
-		}
-
-		if (header.e_version != EV_CURRENT)
-		{
-			dprintln("Invalid ELF version");
-			return false;
-		}
-
-		return true;
-	}
-
-	bool ELF::parse_elf32_program_header(const Elf32ProgramHeader& header)
-	{
-#if ELF_PRINT_HEADERS
-		dprintln("program header");
-		dprintln("  type   {H}", header.p_type);
-		dprintln("  flags  {H}", header.p_flags);
-		dprintln("  offset {H}", header.p_offset);
-		dprintln("  vaddr  {H}", header.p_vaddr);
-		dprintln("  paddr  {H}", header.p_paddr);
-		dprintln("  filesz {}", header.p_filesz);
-		dprintln("  memsz  {}", header.p_memsz);
-		dprintln("  align  {}", header.p_align);
-#endif
-		(void)header;
-		return true;
-	}
-
-	bool ELF::parse_elf32_section_header(const Elf32SectionHeader& header)
-	{
-#if ELF_PRINT_HEADERS
-		if (auto* name = lookup_section_name32(header.sh_name))
-			dprintln("{}", name);
-
-		switch (header.sh_type)
-		{
-			case SHT_NULL:
-				dprintln("  SHT_NULL");
-				break;
-			case SHT_PROGBITS:
-				dprintln("  SHT_PROGBITS");
-				break;
-			case SHT_SYMTAB:
-				for (size_t i = 1; i < header.sh_size / header.sh_entsize; i++)
-				{
-					auto& symbol = ((const Elf32Symbol*)(m_data.data() + header.sh_offset))[i];
-					if (auto* name = lookup_string32(header.sh_link, symbol.st_name))
-						dprintln("  {}", name);
-				}
-				break;
-			case SHT_STRTAB:
-				dprintln("  SHT_STRTAB");
-				break;
-			case SHT_RELA:
-				dprintln("  SHT_RELA");
-				break;
-			case SHT_NOBITS:
-				dprintln("  SHT_NOBITS");
-				break;
-			case SHT_REL:
-				dprintln("  SHT_REL");
-				break;
-			case SHT_SHLIB:
-				dprintln("  SHT_SHLIB");
-				break;
-			case SHT_DYNSYM:
-				dprintln("  SHT_DYNSYM");
-				break;
-			default:
-				ASSERT(false);
-		}
-#endif
-		(void)header;
-		return true;
-	}
-
-	const Elf32FileHeader& ELF::file_header32() const
-	{
-		ASSERT(is_x86_32());
-		return *(const Elf32FileHeader*)m_data.data();
-	}
-
-	const Elf32ProgramHeader& ELF::program_header32(size_t index) const
-	{
-		ASSERT(is_x86_32());
-		const auto& file_header = file_header32();
-		ASSERT(index < file_header.e_phnum);
-		return *(const Elf32ProgramHeader*)(m_data.data() + file_header.e_phoff + file_header.e_phentsize * index);
-	}
-
-	const Elf32SectionHeader& ELF::section_header32(size_t index) const
-	{
-		ASSERT(is_x86_32());
-		const auto& file_header = file_header32();
-		ASSERT(index < file_header.e_shnum);
-		return *(const Elf32SectionHeader*)(m_data.data() + file_header.e_shoff + file_header.e_shentsize * index);
-	}
-
-}

LibELF/LibELF/LoadableELF.cpp

@@ -1,331 +0,0 @@
-#include <BAN/ScopeGuard.h>
-#include <kernel/Memory/Heap.h>
-#include <kernel/Lock/LockGuard.h>
-#include <LibELF/LoadableELF.h>
-#include <LibELF/Values.h>
-
-namespace LibELF
-{
-
-	using namespace Kernel;
-
-	BAN::ErrorOr<BAN::UniqPtr<LoadableELF>> LoadableELF::load_from_inode(PageTable& page_table, BAN::RefPtr<Inode> inode)
-	{
-		auto* elf_ptr = new LoadableELF(page_table, inode);
-		if (elf_ptr == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
-		auto elf = BAN::UniqPtr<LoadableELF>::adopt(elf_ptr);
-		TRY(elf->initialize());
-		return BAN::move(elf);
-	}
-
-	LoadableELF::LoadableELF(PageTable& page_table, BAN::RefPtr<Inode> inode)
-		: m_inode(inode)
-		, m_page_table(page_table)
-	{
-	}
-
-	LoadableELF::~LoadableELF()
-	{
-		if (!m_loaded)
-			return;
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					continue;
-				case PT_LOAD:
-				{
-					vaddr_t start = program_header.p_vaddr & PAGE_ADDR_MASK;
-					size_t pages = range_page_count(program_header.p_vaddr, program_header.p_memsz);
-					for (size_t i = 0; i < pages; i++)
-					{
-						paddr_t paddr = m_page_table.physical_address_of(start + i * PAGE_SIZE);
-						if (paddr != 0)
-							Heap::get().release_page(paddr);
-					}
-					m_page_table.unmap_range(start, pages * PAGE_SIZE);
-					break;
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-	}
-
-	BAN::ErrorOr<void> LoadableELF::initialize()
-	{
-		if ((size_t)m_inode->size() < sizeof(ElfNativeFileHeader))
-		{
-			dprintln("Too small file");
-			return BAN::Error::from_errno(ENOEXEC);
-		}
-
-		size_t nread = TRY(m_inode->read(0, BAN::ByteSpan::from(m_file_header)));
-		ASSERT(nread == sizeof(m_file_header));
-
-		if (m_file_header.e_ident[EI_MAG0] != ELFMAG0 ||
-			m_file_header.e_ident[EI_MAG1] != ELFMAG1 ||
-			m_file_header.e_ident[EI_MAG2] != ELFMAG2 ||
-			m_file_header.e_ident[EI_MAG3] != ELFMAG3)
-		{
-			dprintln("Invalid magic in header");
-			return BAN::Error::from_errno(ENOEXEC);
-		}
-
-		if (m_file_header.e_ident[EI_DATA] != ELFDATA2LSB)
-		{
-			dprintln("Only little-endian is supported");
-			return BAN::Error::from_errno(ENOEXEC);
-		}
-
-		if (m_file_header.e_ident[EI_VERSION] != EV_CURRENT)
-		{
-			dprintln("Invalid version");
-			return BAN::Error::from_errno(ENOEXEC);
-		}
-
-#if ARCH(i686)
-		if (m_file_header.e_ident[EI_CLASS] != ELFCLASS32)
-#elif ARCH(x86_64)
-		if (m_file_header.e_ident[EI_CLASS] != ELFCLASS64)
-#endif
-		{
-			dprintln("Not in native format");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_file_header.e_type != ET_EXEC)
-		{
-			dprintln("Only executable files are supported");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		if (m_file_header.e_version != EV_CURRENT)
-		{
-			dprintln("Unsupported version");
-			return BAN::Error::from_errno(EINVAL);
-		}
-
-		ASSERT(m_file_header.e_phentsize <= sizeof(ElfNativeProgramHeader));
-
-		TRY(m_program_headers.resize(m_file_header.e_phnum));
-		for (size_t i = 0; i < m_file_header.e_phnum; i++)
-		{
-			TRY(m_inode->read(m_file_header.e_phoff + m_file_header.e_phentsize * i, BAN::ByteSpan::from(m_program_headers[i])));
-
-			const auto& pheader = m_program_headers[i];
-			if (pheader.p_type != PT_NULL && pheader.p_type != PT_LOAD)
-			{
-				dprintln("Unsupported program header type {}", pheader.p_type);
-				return BAN::Error::from_errno(ENOTSUP);
-			}
-			if (pheader.p_memsz < pheader.p_filesz)
-			{
-				dprintln("Invalid program header");
-				return BAN::Error::from_errno(EINVAL);
-			}
-
-			m_virtual_page_count += BAN::Math::div_round_up<size_t>((pheader.p_vaddr % PAGE_SIZE) + pheader.p_memsz, PAGE_SIZE);
-		}
-
-		return {};
-	}
-
-	vaddr_t LoadableELF::entry_point() const
-	{
-		return m_file_header.e_entry;
-	}
-
-	bool LoadableELF::contains(vaddr_t address) const
-	{
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					continue;
-				case PT_LOAD:
-					if (program_header.p_vaddr <= address && address < program_header.p_vaddr + program_header.p_memsz)
-						return true;
-					break;
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-		return false;
-	}
-
-	bool LoadableELF::is_address_space_free() const
-	{
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					break;
-				case PT_LOAD:
-				{
-					vaddr_t page_vaddr = program_header.p_vaddr & PAGE_ADDR_MASK;
-					size_t pages = range_page_count(program_header.p_vaddr, program_header.p_memsz);
-					if (!m_page_table.is_range_free(page_vaddr, pages * PAGE_SIZE))
-						return false;
-					break;
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-		return true;
-	}
-
-	void LoadableELF::reserve_address_space()
-	{
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					break;
-				case PT_LOAD:
-				{
-					vaddr_t page_vaddr = program_header.p_vaddr & PAGE_ADDR_MASK;
-					size_t pages = range_page_count(program_header.p_vaddr, program_header.p_memsz);
-					ASSERT(m_page_table.reserve_range(page_vaddr, pages * PAGE_SIZE));
-					break;
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-		m_loaded = true;
-	}
-
-	void LoadableELF::update_suid_sgid(Kernel::Credentials& credentials)
-	{
-		if (m_inode->mode().mode & +Inode::Mode::ISUID)
-			credentials.set_euid(m_inode->uid());
-		if (m_inode->mode().mode & +Inode::Mode::ISGID)
-			credentials.set_egid(m_inode->gid());
-	}
-
-	BAN::ErrorOr<void> LoadableELF::load_page_to_memory(vaddr_t address)
-	{
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					break;
-				case PT_LOAD:
-				{
-					if (!(program_header.p_vaddr <= address && address < program_header.p_vaddr + program_header.p_memsz))
-						continue;
-
-					PageTable::flags_t flags = PageTable::Flags::UserSupervisor | PageTable::Flags::Present;
-					if (program_header.p_flags & LibELF::PF_W)
-						flags |= PageTable::Flags::ReadWrite;
-					if (program_header.p_flags & LibELF::PF_X)
-						flags |= PageTable::Flags::Execute;
-
-					vaddr_t vaddr = address & PAGE_ADDR_MASK;
-					paddr_t paddr = Heap::get().take_free_page();
-					if (paddr == 0)
-						return BAN::Error::from_errno(ENOMEM);
-
-					// Temporarily map page as RW so kernel can write to it
-					m_page_table.map_page_at(paddr, vaddr, PageTable::Flags::ReadWrite | PageTable::Flags::Present);
-					m_physical_page_count++;
-
-					memset((void*)vaddr, 0x00, PAGE_SIZE);
-
-					if (vaddr / PAGE_SIZE < BAN::Math::div_round_up<size_t>(program_header.p_vaddr + program_header.p_filesz, PAGE_SIZE))
-					{
-						size_t vaddr_offset = 0;
-						if (vaddr < program_header.p_vaddr)
-							vaddr_offset = program_header.p_vaddr - vaddr;
-
-						size_t file_offset = 0;
-						if (vaddr > program_header.p_vaddr)
-							file_offset = vaddr - program_header.p_vaddr;
-
-						size_t bytes = BAN::Math::min<size_t>(PAGE_SIZE - vaddr_offset, program_header.p_filesz - file_offset);
-						TRY(m_inode->read(program_header.p_offset + file_offset, { (uint8_t*)vaddr + vaddr_offset, bytes }));
-					}
-
-					// Map page with the correct flags
-					m_page_table.map_page_at(paddr, vaddr, flags);
-
-					return {};
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-		ASSERT_NOT_REACHED();
-	}
-
-
-	BAN::ErrorOr<BAN::UniqPtr<LoadableELF>> LoadableELF::clone(Kernel::PageTable& new_page_table)
-	{
-		auto* elf_ptr = new LoadableELF(new_page_table, m_inode);
-		if (elf_ptr == nullptr)
-			return BAN::Error::from_errno(ENOMEM);
-		auto elf = BAN::UniqPtr<LoadableELF>::adopt(elf_ptr);
-
-		memcpy(&elf->m_file_header, &m_file_header, sizeof(ElfNativeFileHeader));
-
-		TRY(elf->m_program_headers.resize(m_program_headers.size()));
-		memcpy(elf->m_program_headers.data(), m_program_headers.data(), m_program_headers.size() * sizeof(ElfNativeProgramHeader));
-
-		elf->reserve_address_space();
-
-		for (const auto& program_header : m_program_headers)
-		{
-			switch (program_header.p_type)
-			{
-				case PT_NULL:
-					break;
-				case PT_LOAD:
-				{
-					if (!(program_header.p_flags & LibELF::PF_W))
-						continue;
-
-					PageTable::flags_t flags = PageTable::Flags::UserSupervisor | PageTable::Flags::Present;
-					if (program_header.p_flags & LibELF::PF_W)
-						flags |= PageTable::Flags::ReadWrite;
-					if (program_header.p_flags & LibELF::PF_X)
-						flags |= PageTable::Flags::Execute;
-
-					vaddr_t start = program_header.p_vaddr & PAGE_ADDR_MASK;
-					size_t pages = range_page_count(program_header.p_vaddr, program_header.p_memsz);
-
-					for (size_t i = 0; i < pages; i++)
-					{
-						if (m_page_table.physical_address_of(start + i * PAGE_SIZE) == 0)
-							continue;
-
-						paddr_t paddr = Heap::get().take_free_page();
-						if (paddr == 0)
-							return BAN::Error::from_errno(ENOMEM);
-
-						PageTable::with_fast_page(paddr, [&] {
-							memcpy(PageTable::fast_page_as_ptr(), (void*)(start + i * PAGE_SIZE), PAGE_SIZE);
-						});
-
-						new_page_table.map_page_at(paddr, start + i * PAGE_SIZE, flags);
-						elf->m_physical_page_count++;
-					}
-
-					break;
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-
-		return elf;
-	}
-
-}

LibELF/include/LibELF/ELF.h

@@ -1,89 +0,0 @@
-#pragma once
-
-#ifdef __is_kernel
-#include <kernel/FS/Inode.h>
-#include <kernel/Memory/VirtualRange.h>
-#endif
-
-#include <BAN/StringView.h>
-#include <BAN/UniqPtr.h>
-#include <BAN/Vector.h>
-#include <kernel/Arch.h>
-#include "Types.h"
-
-namespace LibELF
-{
-
-	class ELF
-	{
-	public:
-#ifdef __is_kernel
-		static BAN::ErrorOr<BAN::UniqPtr<ELF>> load_from_file(BAN::RefPtr<Kernel::Inode>);
-#else
-		static BAN::ErrorOr<BAN::UniqPtr<ELF>> load_from_file(BAN::StringView);
-#endif
-
-		const Elf64FileHeader& file_header64() const;
-		const Elf64ProgramHeader& program_header64(size_t) const;
-		const Elf64SectionHeader& section_header64(size_t) const;
-		const char* lookup_section_name64(uint32_t) const;
-		const char* lookup_string64(size_t, uint32_t) const;
-#if ARCH(x86_64)
-		const Elf64FileHeader& file_header_native() const { return file_header64(); }
-		const Elf64ProgramHeader& program_header_native(size_t index) const { return program_header64(index); }
-		const Elf64SectionHeader& section_header_native(size_t index) const { return section_header64(index); }
-		const char* lookup_section_name_native(uint32_t offset) const { return lookup_section_name64(offset); }
-		const char* lookup_string_native(size_t table_index, uint32_t offset) const { return lookup_string64(table_index, offset); }
-		bool is_native() const { return is_x86_64(); }
-#endif
-
-		const Elf32FileHeader& file_header32() const;
-		const Elf32ProgramHeader& program_header32(size_t) const;
-		const Elf32SectionHeader& section_header32(size_t) const;
-		const char* lookup_section_name32(uint32_t) const;
-		const char* lookup_string32(size_t, uint32_t) const;
-#if ARCH(i686)
-		const Elf32FileHeader& file_header_native() const { return file_header32(); }
-		const Elf32ProgramHeader& program_header_native(size_t index) const { return program_header32(index); }
-		const Elf32SectionHeader& section_header_native(size_t index) const { return section_header32(index); }
-		const char* lookup_section_name_native(uint32_t offset) const { return lookup_section_name32(offset); }
-		const char* lookup_string_native(size_t table_index, uint32_t offset) const { return lookup_string32(table_index, offset); }
-		bool is_native() const { return is_x86_32(); }
-#endif
-
-		const uint8_t* data() const { return m_data.data(); }
-
-		bool is_x86_32() const;
-		bool is_x86_64() const;
-
-	private:
-//#ifdef __is_kernel
-//		ELF(BAN::UniqPtr<Kernel::VirtualRange>&& storage, size_t size)
-//			: m_storage(BAN::move(storage))
-//			, m_data((const uint8_t*)m_storage->vaddr(), size)
-//		{}
-//#else
-		ELF(BAN::Vector<uint8_t>&& data)
-			: m_data(BAN::move(data))
-		{}
-//#endif
-		BAN::ErrorOr<void> load();
-
-		bool parse_elf64_file_header(const Elf64FileHeader&);
-		bool parse_elf64_program_header(const Elf64ProgramHeader&);
-		bool parse_elf64_section_header(const Elf64SectionHeader&);
-
-		bool parse_elf32_file_header(const Elf32FileHeader&);
-		bool parse_elf32_program_header(const Elf32ProgramHeader&);
-		bool parse_elf32_section_header(const Elf32SectionHeader&);
-
-	private:
-//#ifdef __is_kernel
-//		BAN::UniqPtr<Kernel::VirtualRange> m_storage;
-//		BAN::Span<const uint8_t> m_data;
-//#else
-		const BAN::Vector<uint8_t> m_data;
-//#endif
-	};
-
-}

LibELF/include/LibELF/LoadableELF.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#ifndef __is_kernel
-#error "This is kernel only header"
-#endif
-
-#include <BAN/UniqPtr.h>
-#include <BAN/Vector.h>
-
-#include <kernel/Credentials.h>
-#include <kernel/FS/Inode.h>
-#include <kernel/Memory/PageTable.h>
-
-#include <LibELF/Types.h>
-
-namespace LibELF
-{
-
-	class LoadableELF
-	{
-		BAN_NON_COPYABLE(LoadableELF);
-		BAN_NON_MOVABLE(LoadableELF);
-
-	public:
-		static BAN::ErrorOr<BAN::UniqPtr<LoadableELF>> load_from_inode(Kernel::PageTable&, BAN::RefPtr<Kernel::Inode>);
-		~LoadableELF();
-
-		Kernel::vaddr_t entry_point() const;
-
-		bool contains(Kernel::vaddr_t address) const;
-		bool is_address_space_free() const;
-		void reserve_address_space();
-
-		void update_suid_sgid(Kernel::Credentials&);
-
-		BAN::ErrorOr<void> load_page_to_memory(Kernel::vaddr_t address);
-
-		BAN::ErrorOr<BAN::UniqPtr<LoadableELF>> clone(Kernel::PageTable&);
-
-		size_t virtual_page_count() const { return m_virtual_page_count; }
-		size_t physical_page_count() const { return m_physical_page_count; }
-
-	private:
-		LoadableELF(Kernel::PageTable&, BAN::RefPtr<Kernel::Inode>);
-		BAN::ErrorOr<void> initialize();
-
-	private:
-		BAN::RefPtr<Kernel::Inode>			m_inode;
-		Kernel::PageTable&					m_page_table;
-		ElfNativeFileHeader					m_file_header;
-		BAN::Vector<ElfNativeProgramHeader>	m_program_headers;
-		size_t m_virtual_page_count = 0;
-		size_t m_physical_page_count = 0;
-		bool m_loaded { false };
-	};
-
-}

LibELF/include/LibELF/Values.h

@@ -1,140 +0,0 @@
-#pragma once
-
-namespace LibELF
-{
-
-	enum ELF_Ident
-	{
-		ELFMAG0			= 0x7F,
-		ELFMAG1			= 'E',
-		ELFMAG2			= 'L',
-		ELFMAG3			= 'F',
-
-		ELFCLASSNONE	= 0,
-		ELFCLASS32		= 1,
-		ELFCLASS64		= 2,
-
-		ELFDATANONE		= 0,
-		ELFDATA2LSB		= 1,
-		ELFDATA2MSB		= 2,
-	};
-
-	enum ELF_EI
-	{
-		EI_MAG0			= 0,
-		EI_MAG1			= 1,
-		EI_MAG2			= 2,
-		EI_MAG3			= 3,
-		EI_CLASS		= 4,
-		EI_DATA			= 5,
-		EI_VERSION		= 6,
-		EI_OSABI		= 7,
-		EI_ABIVERSION	= 8,
-		EI_NIDENT		= 16,
-	};
-
-	enum ELF_ET
-	{
-		ET_NONE		= 0,
-		ET_REL		= 1,
-		ET_EXEC		= 2,
-		ET_DYN		= 3,
-		ET_CORE		= 4,
-		ET_LOOS		= 0xfe00,
-		ET_HIOS		= 0xfeff,
-		ET_LOPROC	= 0xff00,
-		ET_HIPROC	= 0xffff,
-	};
-
-	enum ELF_EV
-	{
-		EV_NONE		= 0,
-		EV_CURRENT	= 1,
-	};
-
-	enum ELF_SHT
-	{
-		SHT_NULL		= 0,
-		SHT_PROGBITS	= 1,
-		SHT_SYMTAB		= 2,
-		SHT_STRTAB		= 3,
-		SHT_RELA		= 4,
-		SHT_NOBITS		= 8,
-		SHT_REL			= 9,
-		SHT_SHLIB		= 10,
-		SHT_DYNSYM		= 11,
-		SHT_LOOS		= 0x60000000,
-		SHT_HIOS		= 0x6FFFFFFF,
-		SHT_LOPROC		= 0x70000000,
-		SHT_HIPROC		= 0x7FFFFFFF,
-	};
-
-	enum ELF_SHF
-	{
-		SHF_WRITE		= 0x1,
-		SHF_ALLOC		= 0x2,
-		SHF_EXECINSTR	= 0x4,
-		SHF_MASKOS		= 0x0F000000,
-		SHF_MASKPROC	= 0xF0000000,
-	};
-
-	enum ELF_SHN
-	{
-		SHN_UNDEF	= 0,
-		SHN_LOPROC	= 0xFF00,
-		SHN_HIPROC	= 0xFF1F,
-		SHN_LOOS	= 0xFF20,
-		SHN_HIOS	= 0xFF3F,
-		SHN_ABS		= 0xFFF1,
-		SHN_COMMON	= 0xFFF2,
-	};
-
-	enum ELF_STB
-	{
-		STB_LOCAL	= 0,
-		STB_GLOBAL	= 1,
-		STB_WEAK	= 2,
-		STB_LOOS	= 10,
-		STB_HIOS	= 12,
-		STB_LOPROC	= 13,
-		STB_HIPROC	= 15,
-	};
-
-	enum ELF_STT
-	{
-		STT_NOTYPE	= 0,
-		STT_OBJECT	= 1,
-		STT_FUNC	= 2,
-		STT_SECTION	= 3,
-		STT_FILE	= 4,
-		STT_LOOS	= 10,
-		STT_HIOS	= 12,
-		STT_LOPROC	= 13,
-		STT_HIPROC	= 15,
-	};
-
-	enum ELF_PT
-	{
-		PT_NULL		= 0,
-		PT_LOAD		= 1,
-		PT_DYNAMIC	= 2,
-		PT_INTERP	= 3,
-		PT_NOTE		= 4,
-		PT_SHLIB	= 5,
-		PT_PHDR		= 6,
-		PT_LOOS		= 0x60000000,
-		PT_HIOS		= 0x6FFFFFFF,
-		PT_LOPROC	= 0x70000000,
-		PT_HIPROC	= 0x7FFFFFFF,
-	};
-
-	enum ELF_PF
-	{
-		PF_X		= 0x1,
-		PF_W		= 0x2,
-		PF_R		= 0x4,
-		PF_MASKOS	= 0x00FF0000,
-		PF_MASKPROC	= 0xFF000000,
-	};
-
-}

README.md

@@ -9,6 +9,8 @@ This is my hobby operating system written in C++. Currently supports x86\_64 and
 
 You can find a live demo [here](https://bananymous.com/banan-os)
 
+If you want to try out DOOM, you should first enter the GUI environment using the `start-gui` command. Then you can run `doom` in the GUI terminal.
+
 ### Features
 
 #### General
@@ -18,15 +20,34 @@ You can find a live demo [here](https://bananymous.com/banan-os)
 - [x] Network stack
 - [x] ELF executable loading
 - [x] AML interpreter (partial)
-- [ ] ELF dynamic linking
-- [ ] Graphical desktop
+- [x] Basic graphical environment
+  - [x] Terminal emulator
+  - [x] Status bar
+  - [x] Program launcher
+  - [ ] Some nice apps
+- [x] ELF dynamic linking
+- [x] copy-on-write memory
+  - [x] file mappings
+  - [ ] anonymous mappings
 
 #### Drivers
 - [x] NVMe disks
 - [x] ATA (IDE, SATA) disks
 - [x] E1000 and E1000E NICs
+- [x] RTL8111/8168/8211/8411 NICs
 - [x] PS2 keyboard (all scancode sets)
 - [x] PS2 mouse
+- [x] USB
+  - [x] xHCI
+  - [ ] EHCI
+  - [ ] OHCI
+  - [ ] UHCI
+  - [x] Keyboard
+  - [x] Mouse
+  - [x] Mass storage
+  - [x] Hubs
+  - [ ] ...
+- [ ] virtio devices (network, storage)
 
 #### Network
 - [x] ARP
@@ -35,14 +56,17 @@ You can find a live demo [here](https://bananymous.com/banan-os)
 - [x] UDP
 - [x] TCP (partial and buggy)
 - [x] Unix domain sockets
+- [ ] SSL
 
 #### Filesystems
 - [x] Virtual filesystem
 - [x] Ext2
+- [x] FAT12/16/32
 - [x] Dev
 - [x] Ram
 - [x] Proc
 - [ ] Sys
+- [ ] 9P
 
 #### Bootloader support
 - [x] GRUB
@@ -60,7 +84,7 @@ Each major component and library has its own subdirectory (kernel, userspace, li
 ### Needed packages
 
 #### apt (tested on ubuntu 22.04)
-```# apt install build-essential git ninja-build texinfo bison flex libgmp-dev libmpfr-dev libmpc-dev parted qemu-system-x86```
+```# apt install build-essential git ninja-build texinfo bison flex libgmp-dev libmpfr-dev libmpc-dev parted qemu-system-x86 cpu-checker```
 
 #### pacman
 ```# pacman -S --needed base-devel git wget cmake ninja parted qemu-system-x86```
@@ -94,6 +118,8 @@ To change the bootloader you can set environment variable BANAN\_BOOTLOADER; sup
 
 To run with UEFI set environment variable BANAN\_UEFI\_BOOT=1. You will also have to set OVMF\_PATH to the correct OVMF (default */usr/share/ovmf/x64/OVMF.fd*).
 
+To build an image with no physical root filesystem, but an initrd set environment variable BANAN\_INITRD=1. This can be used when testing on hardware with unsupported USB controller.
+
 If you have corrupted your disk image or want to create new one, you can either manually delete *build/banan-os.img* and build system will automatically create you a new one or you can run the following command.
 ```sh
 ./bos image-full
@@ -103,13 +129,13 @@ I have also created shell completion script for zsh. You can either copy the fil
 
 ## Contributing
 
-As the upstream is hosted on my server https://git.bananymous.com/Bananymous/banan-os, please contact me about account creation ([email](mailto:oskari.alaranta@bananymous.com), [discord](https://discord.gg/xMXKt9Wf)) and I will add a account for you. This is done to limit the people with access to the server.
+As the upstream is hosted on my server https://git.bananymous.com/Bananymous/banan-os, merging contributions is not as trivial as it would be on GitHub. You can still send PRs in GitHub in which case I should be able to download the diff and apply it manually. If you want, I can also provide you an account to my git server. In this case please contact me ([email](mailto:oskari.alaranta@bananymous.com), [discord](https://discord.gg/ehjGySwYdK)).
 
-As this is mostly a learning experience for me, I would appreciate if you first contacted me about adding new features (email, discord, issue, ...). Bug fixes are always welcome!
+As this is mostly a learning experience for me, I would appreciate if you first contacted me about adding new features (email, discord, issue, ...). If you send a PR about something I was planning on doing myself and you didn't ask me, I will probably just close it. Bug fixes are always welcome!
 
 Commit message should be formatted followingly
 
-  1. First line is of the form "_Subject: Description_", where _Subject_ tells the area touched (Kernel, Shell, BuildSystem, ...) and _Description_ is brief description of the change done. First line should fit fully in 70 characters.
+  1. First line is of the form "_Subject: Description_", where _Subject_ tells the area touched (Kernel, Shell, BuildSystem, ...) and _Description_ is brief description of the change done. First line should fit fully in 72 characters.
   2. Body of the message should further describe the change and reasoning behind the change.
 
 All commits should pass the pre-commit hook defined in _.pre-commit-config.yaml_. For instructions on how to setup pre-commit, please see https://pre-commit.com/#install.

bootloader/bios/boot.S

@@ -172,3 +172,5 @@ banan_boot_info:
 		.long framebuffer
 	boot_memory_map:
 		.long memory_map
+	boot_kernel_paddr:
+		.long 0

bootloader/bios/command_line.S

@@ -84,4 +84,4 @@ command_line:
 # 100 character command line
 command_line_buffer:
 	.ascii "root=/dev/sda2"
-	.skip 100 - 28
+	.skip 100 - (. - command_line_buffer)

bootloader/bios/utils.S

@@ -306,20 +306,8 @@ memset32:
 	movw $GDT_DATA32, %dx
 	movw %dx, %es
 
-	movl %ecx, %edx
-
-	andl $3, %ecx
 	rep stosb %es:(%edi)
 
-	movl %edx, %ecx
-	shrl $2, %ecx
-
-	movb %al, %ah
-	movw %ax, %dx
-	shll $16, %eax
-	movw %dx, %ax
-	rep stosl %es:(%edi)
-
 	ljmpl $GDT_CODE16, $.memset32_pmode16
 
  .code16
@@ -370,14 +358,8 @@ memcpy32:
 	movw %dx, %ds
 	movw %dx, %es
 
-	movl %ecx, %edx
-	andl $3, %ecx
 	rep movsb %ds:(%esi), %es:(%edi)
 
-	movl %edx, %ecx
-	shrl $2, %ecx
-	rep movsl %ds:(%esi), %es:(%edi)
-
 	ljmpl $GDT_CODE16, $.memcpy32_pmode16
 
  .code16

bootloader/installer/CMakeLists.txt

@@ -18,5 +18,5 @@ set(SOURCES
 add_executable(banan_os-bootloader-installer ${SOURCES})
 target_compile_options(banan_os-bootloader-installer PRIVATE -O2 -std=c++20)
 target_compile_definitions(banan_os-bootloader-installer PRIVATE __arch=${BANAN_ARCH})
-target_include_directories(banan_os-bootloader-installer PRIVATE ${CMAKE_SOURCE_DIR}/../../LibELF/include)
+target_include_directories(banan_os-bootloader-installer PRIVATE ${CMAKE_SOURCE_DIR}/../../userspace/libraries/LibELF/include)
 target_include_directories(banan_os-bootloader-installer PRIVATE ${CMAKE_SOURCE_DIR}/../../kernel/include)

kernel/CMakeLists.txt

@@ -1,24 +1,16 @@
-cmake_minimum_required(VERSION 3.26)
-
-project(kernel CXX C ASM)
-
-if("${BANAN_ARCH}" STREQUAL "x86_64")
-	set(ELF_FORMAT elf64-x86-64)
-elseif("${BANAN_ARCH}" STREQUAL "i686")
-	set(ELF_FORMAT elf32-i386)
-endif()
-
 set(KERNEL_SOURCES
 	font/prefs.psf.o
 	kernel/ACPI/ACPI.cpp
-	kernel/ACPI/AML.cpp
-	kernel/ACPI/AML/Field.cpp
-	kernel/ACPI/AML/NamedObject.cpp
 	kernel/ACPI/AML/Namespace.cpp
 	kernel/ACPI/AML/Node.cpp
-	kernel/ACPI/AML/Package.cpp
-	kernel/ACPI/AML/Scope.cpp
+	kernel/ACPI/AML/OpRegion.cpp
+	kernel/ACPI/BatterySystem.cpp
+	kernel/ACPI/EmbeddedController.cpp
 	kernel/APIC.cpp
+	kernel/Audio/AC97/Controller.cpp
+	kernel/Audio/Controller.cpp
+	kernel/Audio/HDAudio/AudioFunctionGroup.cpp
+	kernel/Audio/HDAudio/Controller.cpp
 	kernel/BootInfo.cpp
 	kernel/CPUID.cpp
 	kernel/Credentials.cpp
@@ -27,23 +19,29 @@ set(KERNEL_SOURCES
 	kernel/Device/Device.cpp
 	kernel/Device/FramebufferDevice.cpp
 	kernel/Device/NullDevice.cpp
+	kernel/Device/RandomDevice.cpp
 	kernel/Device/ZeroDevice.cpp
+	kernel/ELF.cpp
+	kernel/Epoll.cpp
 	kernel/Errors.cpp
-	kernel/Font.cpp
 	kernel/FS/DevFS/FileSystem.cpp
+	kernel/FS/EventFD.cpp
 	kernel/FS/Ext2/FileSystem.cpp
 	kernel/FS/Ext2/Inode.cpp
+	kernel/FS/FAT/FileSystem.cpp
+	kernel/FS/FAT/Inode.cpp
+	kernel/FS/FileSystem.cpp
 	kernel/FS/Inode.cpp
 	kernel/FS/Pipe.cpp
 	kernel/FS/ProcFS/FileSystem.cpp
 	kernel/FS/ProcFS/Inode.cpp
 	kernel/FS/TmpFS/FileSystem.cpp
 	kernel/FS/TmpFS/Inode.cpp
+	kernel/FS/USTARModule.cpp
 	kernel/FS/VirtualFileSystem.cpp
 	kernel/GDT.cpp
 	kernel/IDT.cpp
-	kernel/Input/KeyboardLayout.cpp
-	kernel/Input/KeyEvent.cpp
+	kernel/Input/InputDevice.cpp
 	kernel/Input/PS2/Controller.cpp
 	kernel/Input/PS2/Device.cpp
 	kernel/Input/PS2/Keyboard.cpp
@@ -52,6 +50,8 @@ set(KERNEL_SOURCES
 	kernel/Interruptable.cpp
 	kernel/InterruptController.cpp
 	kernel/kernel.cpp
+	kernel/Lock/SpinLock.cpp
+	kernel/Memory/ByteRingBuffer.cpp
 	kernel/Memory/DMARegion.cpp
 	kernel/Memory/FileBackedRegion.cpp
 	kernel/Memory/Heap.cpp
@@ -59,14 +59,18 @@ set(KERNEL_SOURCES
 	kernel/Memory/MemoryBackedRegion.cpp
 	kernel/Memory/MemoryRegion.cpp
 	kernel/Memory/PhysicalRange.cpp
+	kernel/Memory/SharedMemoryObject.cpp
 	kernel/Memory/VirtualRange.cpp
 	kernel/Networking/ARPTable.cpp
 	kernel/Networking/E1000/E1000.cpp
 	kernel/Networking/E1000/E1000E.cpp
 	kernel/Networking/IPv4Layer.cpp
+	kernel/Networking/Loopback.cpp
 	kernel/Networking/NetworkInterface.cpp
+	kernel/Networking/NetworkLayer.cpp
 	kernel/Networking/NetworkManager.cpp
 	kernel/Networking/NetworkSocket.cpp
+	kernel/Networking/RTL8169/RTL8169.cpp
 	kernel/Networking/TCPSocket.cpp
 	kernel/Networking/UDPSocket.cpp
 	kernel/Networking/UNIX/Socket.cpp
@@ -78,7 +82,6 @@ set(KERNEL_SOURCES
 	kernel/Processor.cpp
 	kernel/Random.cpp
 	kernel/Scheduler.cpp
-	kernel/Semaphore.cpp
 	kernel/SSP.cpp
 	kernel/Storage/ATA/AHCI/Controller.cpp
 	kernel/Storage/ATA/AHCI/Device.cpp
@@ -90,21 +93,38 @@ set(KERNEL_SOURCES
 	kernel/Storage/NVMe/Namespace.cpp
 	kernel/Storage/NVMe/Queue.cpp
 	kernel/Storage/Partition.cpp
+	kernel/Storage/SCSI.cpp
 	kernel/Storage/StorageDevice.cpp
 	kernel/Syscall.cpp
 	kernel/Terminal/FramebufferTerminal.cpp
+	kernel/Terminal/PseudoTerminal.cpp
 	kernel/Terminal/Serial.cpp
+	kernel/Terminal/TerminalDriver.cpp
+	kernel/Terminal/TextModeTerminal.cpp
 	kernel/Terminal/TTY.cpp
 	kernel/Terminal/VirtualTTY.cpp
 	kernel/Thread.cpp
+	kernel/ThreadBlocker.cpp
 	kernel/Timer/HPET.cpp
 	kernel/Timer/PIT.cpp
 	kernel/Timer/RTC.cpp
 	kernel/Timer/Timer.cpp
+	kernel/USB/Controller.cpp
+	kernel/USB/Device.cpp
+	kernel/USB/HID/HIDDriver.cpp
+	kernel/USB/HID/Joystick.cpp
+	kernel/USB/HID/Keyboard.cpp
+	kernel/USB/HID/Mouse.cpp
+	kernel/USB/Hub/HubDriver.cpp
+	kernel/USB/MassStorage/MassStorageDriver.cpp
+	kernel/USB/MassStorage/SCSIDevice.cpp
+	kernel/USB/USBManager.cpp
+	kernel/USB/XHCI/Controller.cpp
+	kernel/USB/XHCI/Device.cpp
 	icxxabi.cpp
 )
 
-#set(ENABLE_KERNEL_UBSAN True)
+set(ENABLE_KERNEL_UBSAN False)
 
 if(ENABLE_KERNEL_UBSAN)
 	set(KERNEL_SOURCES ${KERNEL_SOURCES} ubsan.cpp)
@@ -119,6 +139,8 @@ if("${BANAN_ARCH}" STREQUAL "x86_64")
 		arch/x86_64/Signal.S
 		arch/x86_64/Syscall.S
 		arch/x86_64/Thread.S
+		arch/x86_64/User.S
+		arch/x86_64/Yield.S
 	)
 elseif("${BANAN_ARCH}" STREQUAL "i686")
 	set(KERNEL_SOURCES
@@ -129,6 +151,8 @@ elseif("${BANAN_ARCH}" STREQUAL "i686")
 		arch/i686/Signal.S
 		arch/i686/Syscall.S
 		arch/i686/Thread.S
+		arch/i686/User.S
+		arch/i686/Yield.S
 	)
 else()
 	message(FATAL_ERROR "unsupported architecure ${BANAN_ARCH}")
@@ -144,62 +168,84 @@ set(BAN_SOURCES
 set(KLIBC_SOURCES
 	klibc/ctype.cpp
 	klibc/string.cpp
+
+	# Ehhh don't do this but for now libc uses the same stuff kernel can use
+	# This won't work after libc starts using sse implemetations tho
+	../userspace/libraries/LibC/arch/${BANAN_ARCH}/string.S
 )
 
-set(LIBELF_SOURCES
-	../LibELF/LibELF/LoadableELF.cpp
+set(LIBDEFLATE_SOURCE
+	../userspace/libraries/LibDEFLATE/Compressor.cpp
+	../userspace/libraries/LibDEFLATE/Decompressor.cpp
+	../userspace/libraries/LibDEFLATE/HuffmanTree.cpp
+)
+
+set(LIBFONT_SOURCES
+	../userspace/libraries/LibFont/Font.cpp
+	../userspace/libraries/LibFont/PSF.cpp
+)
+
+set(LIBINPUT_SOURCE
+	../userspace/libraries/LibInput/KeyboardLayout.cpp
+	../userspace/libraries/LibInput/KeyEvent.cpp
+)
+
+set(LIBQR_SOURCE
+	../userspace/libraries/LibQR/QRCode.cpp
 )
 
 set(KERNEL_SOURCES
 	${KERNEL_SOURCES}
-	${LAI_SOURCES}
 	${BAN_SOURCES}
 	${KLIBC_SOURCES}
-	${LIBELF_SOURCES}
+	${LIBDEFLATE_SOURCE}
+	${LIBFONT_SOURCES}
+	${LIBINPUT_SOURCE}
+	${LIBQR_SOURCE}
 )
 
 add_executable(kernel ${KERNEL_SOURCES})
-add_dependencies(kernel headers)
 
-target_compile_definitions(kernel PUBLIC __is_kernel)
-target_compile_definitions(kernel PUBLIC __arch=${BANAN_ARCH})
+target_compile_definitions(kernel PRIVATE __is_kernel)
+target_compile_definitions(kernel PRIVATE __arch=${BANAN_ARCH})
+target_compile_definitions(kernel PRIVATE LIBDEFLATE_AVOID_STACK=1)
 
-target_compile_options(kernel PUBLIC -O2 -g)
-target_compile_options(kernel PUBLIC $<$<COMPILE_LANGUAGE:CXX>:-Wno-literal-suffix -fno-rtti -fno-exceptions>)
-target_compile_options(kernel PUBLIC -fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}=.)
-target_compile_options(kernel PUBLIC -fstack-protector -ffreestanding -Wall -Wextra -Werror -Wstack-usage=1024 -fno-omit-frame-pointer -mgeneral-regs-only)
+target_compile_options(kernel PRIVATE
+	-O2 -g
+	-fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}=.
+	-fstack-protector
+	-ffreestanding
+	-fno-omit-frame-pointer
+	-fstrict-volatile-bitfields
+	-mgeneral-regs-only
+	-Wall -Wextra -Werror -Wstack-usage=1024
+)
 
-# This might not work with other toolchains
-target_compile_options(kernel PUBLIC $<$<COMPILE_LANGUAGE:CXX>:-Wno-invalid-offsetof>)
+# C++ specific
+target_compile_options(kernel PRIVATE
+	-Wno-literal-suffix
+	-Wno-invalid-offsetof
+	-fno-rtti
+	-fno-exceptions
+)
 
 if(ENABLE_KERNEL_UBSAN)
-	target_compile_options(kernel PUBLIC -fsanitize=undefined)
+	target_compile_options(kernel PRIVATE -fsanitize=undefined)
 endif()
 
 if("${BANAN_ARCH}" STREQUAL "x86_64")
-	target_compile_options(kernel PUBLIC -mcmodel=kernel -mno-red-zone)
-	target_link_options(kernel PUBLIC LINKER:-z,max-page-size=4096)
-	target_link_options(kernel PUBLIC LINKER:-T,${CMAKE_CURRENT_SOURCE_DIR}/arch/x86_64/linker.ld)
+	target_compile_options(kernel PRIVATE -mcmodel=kernel -mno-red-zone)
+	target_link_options(kernel PRIVATE LINKER:-z,max-page-size=4096)
+	target_link_options(kernel PRIVATE LINKER:-T,${CMAKE_CURRENT_SOURCE_DIR}/arch/x86_64/linker.ld)
 elseif("${BANAN_ARCH}" STREQUAL "i686")
-	target_link_options(kernel PUBLIC LINKER:-T,${CMAKE_CURRENT_SOURCE_DIR}/arch/i686/linker.ld)
+	target_link_options(kernel PRIVATE LINKER:-T,${CMAKE_CURRENT_SOURCE_DIR}/arch/i686/linker.ld)
 endif()
 
-target_link_options(kernel PUBLIC -ffreestanding -nostdlib)
+target_link_options(kernel PRIVATE -ffreestanding -nostdlib -orphan-handling=error)
 
-set_source_files_properties(${LAI_SOURCES} PROPERTIES COMPILE_FLAGS -Wno-stack-usage)
-
-add_custom_target(kernel-headers
-	COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different ${CMAKE_CURRENT_SOURCE_DIR}/include/ ${BANAN_INCLUDE}/
-	DEPENDS sysroot
-)
-
-add_custom_target(kernel-install
-	COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_BINARY_DIR}/kernel ${BANAN_BOOT}/banan-os.kernel
-	DEPENDS kernel
-)
-
-execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=crtbegin.o OUTPUT_VARIABLE CRTBEGIN OUTPUT_STRIP_TRAILING_WHITESPACE)
-execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=crtend.o OUTPUT_VARIABLE CRTEND OUTPUT_STRIP_TRAILING_WHITESPACE)
+get_target_property(KERNEL_COMPILE_OPTIONS kernel COMPILE_OPTIONS)
+execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${KERNEL_COMPILE_OPTIONS} -print-file-name=crtbegin.o OUTPUT_VARIABLE CRTBEGIN OUTPUT_STRIP_TRAILING_WHITESPACE)
+execute_process(COMMAND ${CMAKE_CXX_COMPILER} ${KERNEL_COMPILE_OPTIONS} -print-file-name=crtend.o OUTPUT_VARIABLE CRTEND OUTPUT_STRIP_TRAILING_WHITESPACE)
 
 add_custom_command(
 	TARGET kernel PRE_LINK
@@ -214,9 +260,27 @@ add_custom_command(
 #	COMMAND x86_64-banan_os-strip ${CMAKE_CURRENT_BINARY_DIR}/kernel
 #)
 
+banan_include_headers(kernel ban)
+banan_include_headers(kernel libc)
+banan_include_headers(kernel libdeflate)
+banan_include_headers(kernel libelf)
+banan_include_headers(kernel libfont)
+banan_include_headers(kernel libinput)
+banan_include_headers(kernel libqr)
+
+banan_install_headers(kernel)
+set_target_properties(kernel PROPERTIES OUTPUT_NAME banan-os.kernel)
+install(TARGETS kernel DESTINATION ${BANAN_BOOT} OPTIONAL)
+
+if("${BANAN_ARCH}" STREQUAL "x86_64")
+	set(ELF_FORMAT elf64-x86-64)
+elseif("${BANAN_ARCH}" STREQUAL "i686")
+	set(ELF_FORMAT elf32-i386)
+endif()
+
 add_custom_command(
 	OUTPUT font/prefs.psf.o
-	COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && objcopy -O ${ELF_FORMAT} -B i386 -I binary font/prefs.psf ${CMAKE_CURRENT_BINARY_DIR}/font/prefs.psf.o
+	COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR} && mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/font && objcopy -O ${ELF_FORMAT} -B i386 -I binary font/prefs.psf ${CMAKE_CURRENT_BINARY_DIR}/font/prefs.psf.o
 )
 
 set(CMAKE_CXX_LINK_EXECUTABLE "${CMAKE_CXX_COMPILER} <CMAKE_CXX_LINK_FLAGS> <FLAGS> <LINK_FLAGS> -o <TARGET> ${CMAKE_CURRENT_BINARY_DIR}/crti.o ${CMAKE_CURRENT_BINARY_DIR}/crtbegin.o <OBJECTS> ${CMAKE_CURRENT_BINARY_DIR}/crtend.o ${CMAKE_CURRENT_BINARY_DIR}/crtn.o -lgcc ")

kernel/arch/i686/PageTable.cpp

@@ -1,3 +1,4 @@
+#include <kernel/BootInfo.h>
 #include <kernel/CPUID.h>
 #include <kernel/Lock/SpinLock.h>
 #include <kernel/Memory/kmalloc.h>
@@ -9,17 +10,21 @@ extern uint8_t g_kernel_end[];
 extern uint8_t g_kernel_execute_start[];
 extern uint8_t g_kernel_execute_end[];
 
+extern uint8_t g_kernel_writable_start[];
+extern uint8_t g_kernel_writable_end[];
+
 extern uint8_t g_userspace_start[];
 extern uint8_t g_userspace_end[];
 
 namespace Kernel
 {
 
-	RecursiveSpinLock PageTable::s_fast_page_lock;
+	SpinLock PageTable::s_fast_page_lock;
 
 	static PageTable* s_kernel = nullptr;
 	static bool s_has_nxe = false;
 	static bool s_has_pge = false;
+	static bool s_has_pat = false;
 
 	static paddr_t s_global_pdpte = 0;
 
@@ -32,8 +37,6 @@ namespace Kernel
 			result |= Flags::Execute;
 		if (entry & Flags::Reserved)
 			result |= Flags::Reserved;
-		if (entry & Flags::CacheDisable)
-			result |= Flags::CacheDisable;
 		if (entry & Flags::UserSupervisor)
 			result |= Flags::UserSupervisor;
 		if (entry & Flags::ReadWrite)
@@ -43,7 +46,7 @@ namespace Kernel
 		return result;
 	}
 
-	void PageTable::initialize()
+	void PageTable::initialize_pre_heap()
 	{
 		if (CPUID::has_nxe())
 			s_has_nxe = true;
@@ -51,6 +54,9 @@ namespace Kernel
 		if (CPUID::has_pge())
 			s_has_pge = true;
 
+		if (CPUID::has_pat())
+			s_has_pat = true;
+
 		ASSERT(s_kernel == nullptr);
 		s_kernel = new PageTable();
 		ASSERT(s_kernel);
@@ -59,6 +65,11 @@ namespace Kernel
 		s_kernel->initial_load();
 	}
 
+	void PageTable::initialize_post_heap()
+	{
+		// NOTE: this is no-op as our 32 bit target does not use hhdm
+	}
+
 	void PageTable::initial_load()
 	{
 		if (s_has_nxe)
@@ -82,6 +93,17 @@ namespace Kernel
 			);
 		}
 
+		if (s_has_pat)
+		{
+			asm volatile(
+				"movl $0x277, %%ecx;"
+				"rdmsr;"
+				"movw $0x0401, %%dx;"
+				"wrmsr;"
+				::: "eax", "ecx", "edx", "memory"
+			);
+		}
+
 		// enable write protect
 		asm volatile(
 			"movl %%cr0, %%eax;"
@@ -112,6 +134,18 @@ namespace Kernel
 		return (uint64_t*)page;
 	}
 
+	template<typename T>
+	static paddr_t V2P(const T vaddr)
+	{
+		return (vaddr_t)vaddr - KERNEL_OFFSET + g_boot_info.kernel_paddr;
+	}
+
+	template<typename T>
+	static vaddr_t P2V(const T paddr)
+	{
+		return (paddr_t)paddr - g_boot_info.kernel_paddr + KERNEL_OFFSET;
+	}
+
 	void PageTable::initialize_kernel()
 	{
 		ASSERT(s_global_pdpte == 0);
@@ -121,21 +155,13 @@ namespace Kernel
 
 		prepare_fast_page();
 
-		// Map main bios area below 1 MiB
-		map_range_at(
-			0x000E0000,
-			P2V(0x000E0000),
-			0x00100000 - 0x000E0000,
-			PageTable::Flags::Present
-		);
-
 		// Map (phys_kernel_start -> phys_kernel_end) to (virt_kernel_start -> virt_kernel_end)
 		ASSERT((vaddr_t)g_kernel_start % PAGE_SIZE == 0);
 		map_range_at(
 			V2P(g_kernel_start),
 			(vaddr_t)g_kernel_start,
 			g_kernel_end - g_kernel_start,
-			Flags::ReadWrite | Flags::Present
+			Flags::Present
 		);
 
 		// Map executable kernel memory as executable
@@ -146,6 +172,14 @@ namespace Kernel
 			Flags::Execute | Flags::Present
 		);
 
+		// Map writable kernel memory as writable
+		map_range_at(
+			V2P(g_kernel_writable_start),
+			(vaddr_t)g_kernel_writable_start,
+			g_kernel_writable_end - g_kernel_writable_start,
+			Flags::ReadWrite | Flags::Present
+		);
+
 		// Map userspace memory
 		map_range_at(
 			V2P(g_userspace_start),
@@ -159,7 +193,6 @@ namespace Kernel
 	{
 		constexpr uint64_t pdpte = (fast_page() >> 30) & 0x1FF;
 		constexpr uint64_t pde   = (fast_page() >> 21) & 0x1FF;
-		constexpr uint64_t pte   = (fast_page() >> 12) & 0x1FF;
 
 		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(m_highest_paging_struct));
 		ASSERT(pdpt[pdpte] & Flags::Present);
@@ -167,18 +200,15 @@ namespace Kernel
 		uint64_t* pd = reinterpret_cast<uint64_t*>(P2V(pdpt[pdpte]) & PAGE_ADDR_MASK);
 		ASSERT(!(pd[pde] & Flags::Present));
 		pd[pde] = V2P(allocate_zeroed_page_aligned_page()) | Flags::ReadWrite | Flags::Present;
-
-		uint64_t* pt = reinterpret_cast<uint64_t*>(P2V(pd[pde]) & PAGE_ADDR_MASK);
-		ASSERT(!(pt[pte] & Flags::Present));
-		pt[pte] = V2P(allocate_zeroed_page_aligned_page());
 	}
 
 	void PageTable::map_fast_page(paddr_t paddr)
 	{
 		ASSERT(s_kernel);
 		ASSERT(paddr);
+		ASSERT(paddr % PAGE_SIZE == 0);
 
-		SpinLockGuard _(s_fast_page_lock);
+		ASSERT(s_fast_page_lock.current_processor_has_lock());
 
 		constexpr uint64_t pdpte = (fast_page() >> 30) & 0x1FF;
 		constexpr uint64_t pde   = (fast_page() >> 21) & 0x1FF;
@@ -191,14 +221,14 @@ namespace Kernel
 		ASSERT(!(pt[pte] & Flags::Present));
 		pt[pte] = paddr | Flags::ReadWrite | Flags::Present;
 
-		invalidate(fast_page());
+		asm volatile("invlpg (%0)" :: "r"(fast_page()) : "memory");
 	}
 
 	void PageTable::unmap_fast_page()
 	{
 		ASSERT(s_kernel);
 
-		SpinLockGuard _(s_fast_page_lock);
+		ASSERT(s_fast_page_lock.current_processor_has_lock());
 
 		constexpr uint64_t pdpte = (fast_page() >> 30) & 0x1FF;
 		constexpr uint64_t pde   = (fast_page() >> 21) & 0x1FF;
@@ -211,7 +241,7 @@ namespace Kernel
 		ASSERT(pt[pte] & Flags::Present);
 		pt[pte] = 0;
 
-		invalidate(fast_page());
+		asm volatile("invlpg (%0)" :: "r"(fast_page()) : "memory");
 	}
 
 	BAN::ErrorOr<PageTable*> PageTable::create_userspace()
@@ -243,6 +273,9 @@ namespace Kernel
 
 	PageTable::~PageTable()
 	{
+		if (m_highest_paging_struct == 0)
+			return;
+
 		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(m_highest_paging_struct));
 
 		for (uint32_t pdpte = 0; pdpte < 3; pdpte++)
@@ -270,13 +303,25 @@ namespace Kernel
 		Processor::set_current_page_table(this);
 	}
 
-	void PageTable::invalidate(vaddr_t vaddr)
+	void PageTable::invalidate(vaddr_t vaddr, bool send_smp_message)
 	{
 		ASSERT(vaddr % PAGE_SIZE == 0);
 		asm volatile("invlpg (%0)" :: "r"(vaddr) : "memory");
+
+		if (send_smp_message)
+		{
+			Processor::broadcast_smp_message({
+				.type = Processor::SMPMessage::Type::FlushTLB,
+				.flush_tlb = {
+					.vaddr      = vaddr,
+					.page_count = 1,
+					.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
+				}
+			});
+		}
 	}
 
-	void PageTable::unmap_page(vaddr_t vaddr)
+	void PageTable::unmap_page(vaddr_t vaddr, bool send_smp_message)
 	{
 		ASSERT(vaddr);
 		ASSERT(vaddr % PAGE_SIZE == 0);
@@ -293,30 +338,41 @@ namespace Kernel
 		SpinLockGuard _(m_lock);
 
 		if (is_page_free(vaddr))
-		{
-			dwarnln("unmapping unmapped page {8H}", vaddr);
-			return;
-		}
+			Kernel::panic("trying to unmap unmapped page 0x{H}", vaddr);
 
 		uint64_t* pdpt = reinterpret_cast<uint64_t*>(P2V(m_highest_paging_struct));
 		uint64_t* pd   = reinterpret_cast<uint64_t*>(P2V(pdpt[pdpte] & PAGE_ADDR_MASK));
 		uint64_t* pt   = reinterpret_cast<uint64_t*>(P2V(pd[pde] & PAGE_ADDR_MASK));
 
+		const paddr_t old_paddr = pt[pte] & PAGE_ADDR_MASK;
+
 		pt[pte] = 0;
-		invalidate(vaddr);
+
+		if (old_paddr != 0)
+			invalidate(vaddr, send_smp_message);
 	}
 
 	void PageTable::unmap_range(vaddr_t vaddr, size_t size)
 	{
-		vaddr_t s_page = vaddr / PAGE_SIZE;
-		vaddr_t e_page = BAN::Math::div_round_up<vaddr_t>(vaddr + size, PAGE_SIZE);
+		ASSERT(vaddr % PAGE_SIZE == 0);
+
+		size_t page_count = range_page_count(vaddr, size);
 
 		SpinLockGuard _(m_lock);
-		for (vaddr_t page = s_page; page < e_page; page++)
-			unmap_page(page * PAGE_SIZE);
+		for (vaddr_t page = 0; page < page_count; page++)
+			unmap_page(vaddr + page * PAGE_SIZE, false);
+
+		Processor::broadcast_smp_message({
+			.type = Processor::SMPMessage::Type::FlushTLB,
+			.flush_tlb = {
+				.vaddr      = vaddr,
+				.page_count = page_count,
+				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
+			}
+		});
 	}
 
-	void PageTable::map_page_at(paddr_t paddr, vaddr_t vaddr, flags_t flags)
+	void PageTable::map_page_at(paddr_t paddr, vaddr_t vaddr, flags_t flags, MemoryType memory_type, bool send_smp_message)
 	{
 		ASSERT(vaddr);
 		ASSERT(vaddr != fast_page());
@@ -338,8 +394,13 @@ namespace Kernel
 			extra_flags |= 1ull << 63;
 		if (flags & Flags::Reserved)
 			extra_flags |= Flags::Reserved;
-		if (flags & Flags::CacheDisable)
-			extra_flags |= Flags::CacheDisable;
+
+		if (memory_type == MemoryType::Uncached)
+			extra_flags |= (1ull << 4);
+		if (s_has_pat && memory_type == MemoryType::WriteCombining)
+			extra_flags |= (1ull << 7);
+		if (s_has_pat && memory_type == MemoryType::WriteThrough)
+			extra_flags |= (1ull << 7) | (1ull << 3);
 
 		// NOTE: we add present here, since it has to be available in higher level structures
 		flags_t uwr_flags = (flags & (Flags::UserSupervisor | Flags::ReadWrite)) | Flags::Present;
@@ -362,12 +423,16 @@ namespace Kernel
 			uwr_flags &= ~Flags::Present;
 
 		uint64_t* pt = reinterpret_cast<uint64_t*>(P2V(pd[pde] & PAGE_ADDR_MASK));
+
+		const paddr_t old_paddr = pt[pte] & PAGE_ADDR_MASK;
+
 		pt[pte] = paddr | uwr_flags | extra_flags;
 
-		invalidate(vaddr);
+		if (old_paddr != 0)
+			invalidate(vaddr, send_smp_message);
 	}
 
-	void PageTable::map_range_at(paddr_t paddr, vaddr_t vaddr, size_t size, flags_t flags)
+	void PageTable::map_range_at(paddr_t paddr, vaddr_t vaddr, size_t size, flags_t flags, MemoryType memory_type)
 	{
 		ASSERT(vaddr);
 		ASSERT(paddr % PAGE_SIZE == 0);
@@ -377,7 +442,16 @@ namespace Kernel
 
 		SpinLockGuard _(m_lock);
 		for (size_t page = 0; page < page_count; page++)
-			map_page_at(paddr + page * PAGE_SIZE, vaddr + page * PAGE_SIZE, flags);
+			map_page_at(paddr + page * PAGE_SIZE, vaddr + page * PAGE_SIZE, flags, memory_type, false);
+
+		Processor::broadcast_smp_message({
+			.type = Processor::SMPMessage::Type::FlushTLB,
+			.flush_tlb = {
+				.vaddr      = vaddr,
+				.page_count = page_count,
+				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
+			}
+		});
 	}
 
 	uint64_t PageTable::get_page_data(vaddr_t vaddr) const
@@ -434,13 +508,13 @@ namespace Kernel
 		return true;
 	}
 
-	bool PageTable::reserve_page(vaddr_t vaddr, bool only_free)
+	bool PageTable::reserve_page(vaddr_t vaddr, bool only_free, bool send_smp_message)
 	{
 		SpinLockGuard _(m_lock);
 		ASSERT(vaddr % PAGE_SIZE == 0);
 		if (only_free && !is_page_free(vaddr))
 			return false;
-		map_page_at(0, vaddr, Flags::Reserved);
+		map_page_at(0, vaddr, Flags::Reserved, MemoryType::Normal, send_smp_message);
 		return true;
 	}
 
@@ -454,7 +528,15 @@ namespace Kernel
 		if (only_free && !is_range_free(vaddr, bytes))
 			return false;
 		for (size_t offset = 0; offset < bytes; offset += PAGE_SIZE)
-			reserve_page(vaddr + offset);
+			reserve_page(vaddr + offset, true, false);
+		Processor::broadcast_smp_message({
+			.type = Processor::SMPMessage::Type::FlushTLB,
+			.flush_tlb = {
+				.vaddr      = vaddr,
+				.page_count = bytes / PAGE_SIZE,
+				.page_table = vaddr < KERNEL_OFFSET ? this : nullptr,
+			}
+		});
 		return true;
 	}
 

kernel/arch/i686/Signal.S

@@ -1,35 +1,73 @@
-.section .userspace, "aw"
+.section .userspace, "ax"
 
 // stack contains
 //    return address
+//    return stack
+//    return rflags
+//    siginfo_t
 //    signal number
 //    signal handler
 
 .global signal_trampoline
 signal_trampoline:
+	pushl %esi // gregs
+	pushl %edi
+	pushl %edx
+	pushl %ecx
+	pushl %ebx
+	pushl %eax
 	pushl %ebp
-	movl %esp, %ebp
 
-	pusha
+	// FIXME: populate these
+	xorl %eax, %eax
+	pushl %eax // stack
+	pushl %eax
+	pushl %eax
+	pushl %eax // sigset
+	pushl %eax
+	pushl %eax // link
 
-	movl 40(%esp), %edi
-	movl 36(%esp), %eax
+	movl    %esp,  %edx // ucontext
+	leal 60(%esp), %esi // siginfo
+	movl 56(%esp), %edi // signal number
+	movl 52(%esp), %eax // handlers
 
 	// align stack to 16 bytes
-	movl %esp, %ebx
-	andl $0x0F, %ebx
-	subl %ebx, %esp
+	movl %esp, %ebp
+	andl $-16, %esp
 
-	subl $12, %esp
+	subl $512, %esp
+	fxsave (%esp)
+
+	subl $4, %esp
+	pushl %edx
+	pushl %esi
 	pushl %edi
 	call *%eax
 	addl $16, %esp
 
-	// restore stack
-	addl %ebx, %esp
-	popa
+	fxrstor (%esp)
+	addl $512, %esp
 
-	leave
-	addl $8, %esp
+	// restore stack
+	movl %ebp, %esp
+	addl $24, %esp
+
+	// restore registers
+	popl %ebp
+	popl %eax
+	popl %ebx
+	popl %ecx
+	popl %edx
+	popl %edi
+	popl %esi
+
+	// skip handler, number, siginfo_t
+	addl $44, %esp
+
+	// restore flags
+	popf
+
+	movl (%esp), %esp
 
 	ret

kernel/arch/i686/Syscall.S

@@ -1,12 +1,6 @@
 // arguments in EAX, EBX, ECX, EDX, ESI, EDI
 .global asm_syscall_handler
 asm_syscall_handler:
-	# save segment registers
-	pushw %ds
-	pushw %es
-	pushw %fs
-	pushw %gs
-
 	# save general purpose registers
 	pushl %ebx
 	pushl %ecx
@@ -14,10 +8,14 @@ asm_syscall_handler:
 	pushl %edi
 	pushl %esi
 	pushl %ebp
+	cld
 
-	# align stack and push arguments
-	pushl %esp
-	addl $32, (%esp)
+	# align stack
+	movl %esp, %ebp
+	andl $-16, %esp
+
+	# push arguments
+	subl $8, %esp
 	pushl %edi
 	pushl %esi
 	pushl %edx
@@ -34,7 +32,17 @@ asm_syscall_handler:
 	movw %ax, %gs
 
 	call cpp_syscall_handler
-	addl $28, %esp
+
+	movl %ebp, %esp
+
+	# restore userspace segments
+	movw $(0x20 | 3), %bx
+	movw %bx, %ds
+	movw %bx, %es
+	movw $(0x30 | 3), %bx
+	movw %bx, %fs
+	movw $(0x38 | 3), %bx
+	movw %bx, %gs
 
 	# restore general purpose registers
 	popl %ebp
@@ -44,12 +52,6 @@ asm_syscall_handler:
 	popl %ecx
 	popl %ebx
 
-	# restore segment registers
-	popw %gs
-	popw %fs
-	popw %es
-	popw %ds
-
 	iret
 
 .global sys_fork_trampoline

kernel/arch/i686/Thread.S

@@ -31,38 +31,18 @@ start_kernel_thread:
 	subl $12, %esp
 	pushl %edi
 	call *%esi
-	addl $16, %esp
-
 
 .global start_userspace_thread
 start_userspace_thread:
 	call get_thread_start_sp
 	movl %eax, %esp
 
-	# STACK LAYOUT
-	#   entry
-	#   argc
-	#   argv
-	#   envp
-	#   userspace stack
-
-	call get_userspace_thread_stack_top
-
 	movw $(0x20 | 3), %bx
 	movw %bx, %ds
 	movw %bx, %es
+	movw $(0x30 | 3), %bx
 	movw %bx, %fs
+	movw $(0x38 | 3), %bx
 	movw %bx, %gs
-	xorw %bx, %bx
 
-	popl %edx
-	popl %esi
-	popl %edi
-	popl %ecx
-
-	pushl $(0x20 | 3)
-	pushl %eax
-	pushl $0x202
-	pushl $(0x18 | 3)
-	pushl %ecx
 	iret

kernel/arch/i686/User.S

@@ -0,0 +1,54 @@
+# bool safe_user_memcpy(void*, const void*, size_t)
+.global safe_user_memcpy
+.global safe_user_memcpy_end
+.global safe_user_memcpy_fault
+safe_user_memcpy:
+	xorl %eax, %eax
+	xchgl 4(%esp), %edi
+	xchgl 8(%esp), %esi
+	movl 12(%esp), %ecx
+	movl %edi, %edx
+	rep movsb
+	movl 4(%esp), %edi
+	movl 8(%esp), %esi
+	incl %eax
+safe_user_memcpy_fault:
+	ret
+safe_user_memcpy_end:
+
+# bool safe_user_strncpy(void*, const void*, size_t)
+.global safe_user_strncpy
+.global safe_user_strncpy_end
+.global safe_user_strncpy_fault
+safe_user_strncpy:
+	xchgl 4(%esp), %edi
+	xchgl 8(%esp), %esi
+	movl 12(%esp), %ecx
+
+	testl %ecx, %ecx
+	jz safe_user_strncpy_fault
+
+ .safe_user_strncpy_loop:
+	movb (%esi), %al
+	movb %al, (%edi)
+	testb %al, %al
+	jz .safe_user_strncpy_done
+
+	incl %edi
+	incl %esi
+	decl %ecx
+	jnz .safe_user_strncpy_loop
+
+ safe_user_strncpy_fault:
+	xorl %eax, %eax
+	jmp .safe_user_strncpy_return
+
+ .safe_user_strncpy_done:
+	movl $1, %eax
+
+ .safe_user_strncpy_return:
+	movl 4(%esp), %edi
+	movl 8(%esp), %esi
+	ret
+
+safe_user_strncpy_end:

kernel/arch/i686/Yield.S

@@ -0,0 +1,25 @@
+.global asm_yield_trampoline
+asm_yield_trampoline:
+	leal 4(%esp), %ecx
+	movl 4(%esp), %esp
+
+	pushl -4(%ecx)
+	pushl %ecx
+	pushl %eax
+	pushl %ebx
+	pushl %esi
+	pushl %edi
+	pushl %ebp
+
+	pushl %esp
+	call scheduler_on_yield
+	addl $4, %esp
+
+	popl %ebp
+	popl %edi
+	popl %esi
+	popl %ebx
+	popl %eax
+	movl 4(%esp), %ecx
+	movl 0(%esp), %esp
+	jmp *%ecx

kernel/arch/i686/boot.S

@@ -14,6 +14,23 @@
 # multiboot2 header
 .section .multiboot, "aw"
 	.align 8
+multiboot_start:
+	.long 0x1BADB002
+	.long (1 << 2) # page align modules
+	.long -(0x1BADB002 + (1 << 2))
+
+	.long 0
+	.long 0
+	.long 0
+	.long 0
+	.long 0
+
+	.long 0
+	.long FB_WIDTH
+	.long FB_HEIGHT
+	.long FB_BPP
+multiboot_end:
+	.align 8
 multiboot2_start:
 	.long 0xE85250D6
 	.long 0
@@ -36,6 +53,12 @@ multiboot2_start:
 	.long 12
 	.long V2P(_start)
 
+	# page align modules
+	.align 8
+	.short 6
+	.short 0
+	.long 8
+
 	.align 8
 	.short 0
 	.short 0
@@ -53,10 +76,10 @@ bananboot_start:
 bananboot_end:
 
 .section .bss, "aw", @nobits
-	.align 4096
-	boot_stack_bottom:
+    .global g_boot_stack_top
+	g_boot_stack_bottom:
 		.skip 4096 * 4
-	boot_stack_top:
+	g_boot_stack_top:
 
 	.global g_kernel_cmdline
 	g_kernel_cmdline:
@@ -161,6 +184,13 @@ enable_sse:
 	movl %eax, %cr4
 	ret
 
+enable_tsc:
+	# allow userspace to use RDTSC
+	movl %cr4, %ecx
+	andl $0xFFFFFFFB, %ecx
+	movl %ecx, %cr4
+	ret
+
 initialize_paging:
 	# enable PAE
 	movl %cr4, %ecx
@@ -188,7 +218,7 @@ _start:
 	movl %ebx, V2P(bootloader_info)
 
 	# load boot stack
-	movl $V2P(boot_stack_top), %esp
+	movl $V2P(g_boot_stack_top), %esp
 
 	# load boot GDT
 	lgdt V2P(boot_gdtr)
@@ -203,10 +233,11 @@ gdt_flush:
 	# do processor initialization
 	call check_requirements
 	call enable_sse
+	call enable_tsc
 	call initialize_paging
 
 	# load higher half stack pointer
-	movl $boot_stack_top, %esp
+	movl $g_boot_stack_top, %esp
 
 	# jump to higher half
 	leal higher_half, %ecx
@@ -216,6 +247,13 @@ higher_half:
 	# call global constuctors
 	call _init
 
+	movl $g_init_array_start, %ebx
+	jmp 2f
+ 1: call *(%ebx)
+	addl $4, %ebx
+ 2: cmpl $g_init_array_end, %ebx
+	jne 1b
+
 	# call to the kernel itself (clear ebp for stacktrace)
 	xorl %ebp, %ebp
 
@@ -235,26 +273,31 @@ system_halt:
 	jmp 1b
 
 
+#define AP_V2P(vaddr) ((vaddr) - ap_trampoline + 0xF000)
+
 .section .ap_init, "ax"
 
 .code16
 .global ap_trampoline
 ap_trampoline:
 	jmp 1f
+
 .align 8
 ap_stack_ptr:
 	.skip 4
-1:
-	cli; cld
-	ljmpl $0x00, $ap_cs_clear
-ap_cs_clear:
+ap_stack_loaded:
+	.skip 1
 
+1:	cli; cld
+	ljmpl $0x00, $AP_V2P(ap_cs_clear)
+
+ap_cs_clear:
 	# load ap gdt and enter protected mode
-	lgdt ap_gdtr
+	lgdt AP_V2P(ap_gdtr)
 	movl %cr0, %eax
 	orb $1, %al
 	movl %eax, %cr0
-	ljmpl $0x08, $ap_protected_mode
+	ljmpl $0x08, $AP_V2P(ap_protected_mode)
 
 .code32
 ap_protected_mode:
@@ -263,16 +306,16 @@ ap_protected_mode:
 	movw %ax, %ss
 	movw %ax, %es
 
-	movl ap_stack_ptr, %esp
-	movb $1, V2P(g_ap_stack_loaded)
+	movl AP_V2P(ap_stack_ptr), %esp
+	movb $1, AP_V2P(ap_stack_loaded)
 
-	call V2P(enable_sse)
-
-	call V2P(initialize_paging)
+	leal V2P(enable_sse),        %ecx; call *%ecx
+	leal V2P(enable_tsc),        %ecx; call *%ecx
+	leal V2P(initialize_paging), %ecx; call *%ecx
 
 	# load boot gdt and enter long mode
 	lgdt V2P(boot_gdtr)
-	ljmpl $0x08, $ap_flush_gdt
+	ljmpl $0x08, $AP_V2P(ap_flush_gdt)
 
 ap_flush_gdt:
 	# move stack pointer to higher half

kernel/arch/i686/crt0.S

@@ -1,23 +0,0 @@
-.section .text
-
-.global _start
-_start:
-	# Set up end of the stack frame linked list.
-	movl $0, %ebp
-	pushl %ebp # rip=0
-	pushl %ebp # rbp=0
-	movl %esp, %ebp
-
-	# Prepare signals, memory allocation, stdio and such.
-	#call initialize_standard_library
-
-	# Run the global constructors.
-	call _init
-
-	# Run main
-	call main
-
-	# Terminate the process with the exit code.
-	movl %eax, %edi
-	call exit
-.size _start, . - _start

kernel/arch/i686/crti.S

@@ -1,9 +1,9 @@
-/* x86 crti.s */
+/* i686 crti.s */
 .section .init
 .global _init
 .type _init, @function
 _init:
-	push %ebp
+	pushl %ebp
 	movl %esp, %ebp
 	/* gcc will nicely put the contents of crtbegin.o's .init section here. */
 
@@ -11,6 +11,6 @@ _init:
 .global _fini
 .type _fini, @function
 _fini:
-	push %ebp
+	pushl %ebp
 	movl %esp, %ebp
 	/* gcc will nicely put the contents of crtbegin.o's .fini section here. */

kernel/arch/i686/crtn.S

@@ -1,4 +1,4 @@
-/* x86 crtn.s */
+/* i686 crtn.s */
 .section .init
 	/* gcc will nicely put the contents of crtend.o's .init section here. */
 	popl %ebp

kernel/arch/i686/interrupts.S

@@ -1,84 +1,119 @@
-.macro push_userspace
-	pushw %gs
-	pushw %fs
-	pushw %es
-	pushw %ds
-	pushal
-.endm
+.macro maybe_load_kernel_segments, n
+	testb $3, \n(%esp)
+	jz 1f; jnp 1f
 
-.macro load_kernel_segments
 	movw $0x10, %ax
 	movw %ax, %ds
 	movw %ax, %es
 	movw %ax, %fs
-
 	movw $0x28, %ax
 	movw %ax, %gs
+1:
 .endm
 
-.macro pop_userspace
-	popal
-	popw %ds
-	popw %es
-	popw %fs
-	popw %gs
+.macro maybe_load_userspace_segments, n
+	testb $3, \n(%esp)
+	jz 1f; jnp 1f
+
+	movw $(0x20 | 3), %bx
+	movw %bx, %ds
+	movw %bx, %es
+	movw $(0x30 | 3), %bx
+	movw %bx, %fs
+	movw $(0x38 | 3), %bx
+	movw %bx, %gs
+1:
 .endm
 
 isr_stub:
-	push_userspace
-	load_kernel_segments
+	pushal
+	maybe_load_kernel_segments 44
+	cld
 
 	movl %cr0, %eax; pushl %eax
 	movl %cr2, %eax; pushl %eax
 	movl %cr3, %eax; pushl %eax
 	movl %cr4, %eax; pushl %eax
 
-	movl %esp,     %eax // register ptr
-	leal 64(%esp), %ebx // interrupt stack ptr
-	movl 60(%esp), %ecx // error code
-	movl 56(%esp), %edx // isr number
+	movl 48(%esp), %edi // isr number
+	movl 52(%esp), %esi // error code
+	leal 56(%esp), %edx // interrupt stack ptr
+	movl %esp,     %ecx // register ptr
+
+	# stack frame for stack trace
+	leal 56(%esp), %eax
+	pushl (%eax)
+	pushl %ebp
+
+	movl %esp, %ebp
+	andl $-16, %esp
 
-	subl $12, %esp
-	pushl %eax
-	pushl %ebx
 	pushl %ecx
 	pushl %edx
+	pushl %esi
+	pushl %edi
 	call cpp_isr_handler
-	addl $44, %esp
 
-	pop_userspace
+	movl %ebp, %esp
+	addl $24, %esp
+
+	maybe_load_userspace_segments 44
+	popal
 	addl $8, %esp
 	iret
 
 irq_stub:
-	push_userspace
-	load_kernel_segments
+	pushal
+	maybe_load_kernel_segments 44
+	cld
 
-	movl 40(%esp), %eax # interrupt number
+	movl 32(%esp), %edi # interrupt number
+
+	movl %esp, %ebp
+	andl $-16, %esp
 
 	subl $12, %esp
-	pushl %eax
+	pushl %edi
 	call cpp_irq_handler
-	addl $16, %esp
 
-	pop_userspace
+	movl %ebp, %esp
+
+	maybe_load_userspace_segments 44
+	popal
 	addl $8, %esp
 	iret
 
-.global asm_yield_handler
-asm_yield_handler:
-	# This can only be called from kernel, so no segment saving is needed
+.global asm_ipi_handler
+asm_ipi_handler:
 	pushal
+	maybe_load_kernel_segments 36
+	cld
 
-	movl %esp,     %eax # interrupt registers ptr
-	leal 32(%esp), %ebx # interrupt stack ptr
+	movl %esp, %ebp
+	andl $-16, %esp
 
-	subl $4, %esp
-	pushl %eax
-	pushl %ebx
-	call cpp_yield_handler
-	addl $12, %esp
+	call cpp_ipi_handler
 
+	movl %ebp, %esp
+
+	maybe_load_userspace_segments 36
+	popal
+	iret
+
+.global asm_timer_handler
+asm_timer_handler:
+	pushal
+	maybe_load_kernel_segments 36
+	cld
+
+	movl %esp, %ebp
+	andl $-16, %esp
+
+	call cpp_timer_handler
+
+	movl %ebp, %esp
+
+	maybe_load_userspace_segments 36
 	popal
 	iret
 
@@ -138,36 +173,26 @@ isr 29
 isr 30
 isr 31
 
-irq 0
-irq 1
-irq 2
-irq 3
-irq 4
-irq 5
-irq 6
-irq 7
-irq 8
-irq 9
-irq 10
-irq 11
-irq 12
-irq 13
-irq 14
-irq 15
-irq 16
-irq 17
-irq 18
-irq 19
-irq 20
-irq 21
-irq 22
-irq 23
-irq 24
-irq 25
-irq 26
-irq 27
-irq 28
-irq 29
-irq 30
-irq 31
-irq 32
+.irp i,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, \
+        10, 11, 12, 13, 14, 15, 16, 17, 18, 19, \
+        20, 21, 22, 23, 24, 25, 26, 27, 28, 29, \
+        30, 31, 32, 33, 34, 35, 36, 37, 38, 39, \
+        40, 41, 42, 43, 44, 45, 46, 47, 48, 49, \
+        50, 51, 52, 53, 54, 55, 56, 57, 58, 59, \
+        60, 61, 62, 63, 64, 65, 66, 67, 68, 69, \
+        70, 71, 72, 73, 74, 75, 76, 77, 78, 79, \
+        80, 81, 82, 83, 84, 85, 86, 87, 88, 89, \
+        90, 91, 92, 93, 94, 95, 96, 97, 98, 99, \
+       100,101,102,103,104,105,106,107,108,109, \
+       110,111,112,113,114,115,116,117,118,119, \
+       120,121,122,123,124,125,126,127,128,129, \
+       130,131,132,133,134,135,136,137,138,139, \
+       140,141,142,143,144,145,146,147,148,149, \
+       150,151,152,153,154,155,156,157,158,159, \
+       160,161,162,163,164,165,166,167,168,169, \
+       170,171,172,173,174,175,176,177,178,179, \
+       180,181,182,183,184,185,186,187,188,189, \
+       190,191,192,193,194,195,196,197,198,199, \
+       200,201,202,203,204,205,206,207
+	irq \i
+.endr

kernel/arch/i686/linker.ld

@@ -4,13 +4,6 @@ KERNEL_OFFSET = 0xC0000000;
 
 SECTIONS
 {
-	. = 0xF000;
-	.ap_init ALIGN(4K) : AT(ADDR(.ap_init))
-	{
-		g_ap_init_addr = .;
-		*(.ap_init)
-	}
-
 	. = 0x00100000 + KERNEL_OFFSET;
 
 	g_kernel_start = .;
@@ -28,18 +21,31 @@ SECTIONS
 		g_userspace_end = .;
 		g_kernel_execute_end = .;
 	}
+	.ap_init ALIGN(4K) : AT(ADDR(.ap_init) - KERNEL_OFFSET)
+	{
+		g_ap_init_addr = .;
+		*(.ap_init)
+	}
 	.rodata ALIGN(4K) : AT(ADDR(.rodata) - KERNEL_OFFSET)
 	{
 		*(.rodata.*)
 	}
+	.init_array ALIGN(4K) : AT(ADDR(.init_array) - KERNEL_OFFSET)
+	{
+		g_init_array_start = .;
+		*(.init_array)
+		g_init_array_end = .;
+	}
 	.data ALIGN(4K) : AT(ADDR(.data) - KERNEL_OFFSET)
 	{
+		g_kernel_writable_start = .;
 		*(.data)
 	}
 	.bss ALIGN(4K) : AT(ADDR(.bss) - KERNEL_OFFSET)
 	{
 		*(COMMON)
 		*(.bss)
+		g_kernel_writable_end = .;
 	}
 	g_kernel_end = .;
 }

kernel/arch/x86_64/Signal.S

@@ -1,57 +1,84 @@
-.section .userspace, "aw"
+.section .userspace, "ax"
 
 // stack contains
 //    return address
+//    return stack
+//    return rflags
+//    siginfo_t
 //    signal number
 //    signal handler
 
 .global signal_trampoline
 signal_trampoline:
-	pushq %rax
-	pushq %rbx
-	pushq %rcx
-	pushq %rdx
-	pushq %rbp
-	pushq %rdi
-	pushq %rsi
-	pushq %r8
-	pushq %r9
-	pushq %r10
-	pushq %r11
-	pushq %r12
-	pushq %r13
+	pushq %r15 // gregs
 	pushq %r14
-	pushq %r15
+	pushq %r13
+	pushq %r12
+	pushq %r11
+	pushq %r10
+	pushq %r9
+	pushq %r8
+	pushq %rsi
+	pushq %rdi
+	pushq %rdx
+	pushq %rcx
+	pushq %rbx
+	pushq %rax
+	pushq %rbp
 
-	movq 128(%rsp), %rdi
-	movq 120(%rsp), %rax
+	// FIXME: populate these
+	xorq %rax, %rax
+	pushq %rax // stack
+	pushq %rax
+	pushq %rax
+	pushq %rax // sigset
+	pushq %rax // link
+
+	movq  %rsp,     %rdx // ucontext
+	leaq 176(%rsp), %rsi // siginfo
+	movq 168(%rsp), %rdi // signal number
+	movq 160(%rsp), %rax // handler
 
 	// align stack to 16 bytes
-	movq %rsp, %rbx
-	andq $0x0F, %rbx
-	subq %rbx, %rsp
+	movq %rsp, %rbp
+	andq $-16, %rsp
+
+	subq $512, %rsp
+	fxsave64 (%rsp)
 
 	call *%rax
 
+	fxrstor64 (%rsp)
+	addq $512, %rsp
+
 	// restore stack
-	addq %rbx, %rsp
-	popq %r15
-	popq %r14
-	popq %r13
-	popq %r12
-	popq %r11
-	popq %r10
-	popq %r9
-	popq %r8
-	popq %rsi
-	popq %rdi
+	movq %rbp, %rsp
+	addq $40, %rsp
+
+	// restore registers
 	popq %rbp
-	popq %rdx
-	popq %rcx
-	popq %rbx
 	popq %rax
+	popq %rbx
+	popq %rcx
+	popq %rdx
+	popq %rdi
+	popq %rsi
+	popq %r8
+	popq %r9
+	popq %r10
+	popq %r11
+	popq %r12
+	popq %r13
+	popq %r14
+	popq %r15
 
-	addq $16, %rsp
+	// skip handler, number, siginfo_t
+	addq $72, %rsp
 
-	// return over red-zone
+	// restore flags
+	popfq
+
+	movq (%rsp), %rsp
+
+	// return over red-zone and siginfo_t
 	ret $128

kernel/arch/x86_64/Syscall.S

@@ -1,48 +1,26 @@
-// arguments in RAX, RBX, RCX, RDX, RSI, RDI
-// System V ABI: RDI, RSI, RDX, RCX, R8, R9
 .global asm_syscall_handler
 asm_syscall_handler:
-	pushq %rbx
-	pushq %rcx
-	pushq %rdx
-	pushq %rdi
-	pushq %rsi
-	pushq %rbp
-	pushq %r8
-	pushq %r9
-	pushq %r10
+	swapgs
+
+	movq %rsp, %rax
+	movq %gs:8, %rsp
+
+	pushq $(0x20 | 3)
+	pushq %rax
 	pushq %r11
-	pushq %r12
-	pushq %r13
-	pushq %r14
-	pushq %r15
+	pushq $(0x28 | 3)
+	pushq %rcx
+	subq $8, %rsp
 
-	movq %rsi, %r8
-	movq %rdi, %r9
-	movq %rax, %rdi
-	movq %rbx, %rsi
-	xchgq %rcx, %rdx
-	leaq 112(%rsp), %rbx
-	pushq %rbx
+	movq %r10, %rcx
 	call cpp_syscall_handler
-	addq $8, %rsp
 
-	popq %r15
-	popq %r14
-	popq %r13
-	popq %r12
-	popq %r11
-	popq %r10
-	popq %r9
-	popq %r8
-	popq %rbp
-	popq %rsi
-	popq %rdi
-	popq %rdx
-	popq %rcx
-	popq %rbx
-	iretq
+	movq  8(%rsp), %rcx
+	movq 24(%rsp), %r11
+	movq 32(%rsp), %rsp
 
+	swapgs
+	sysretq
 
 .global sys_fork_trampoline
 sys_fork_trampoline:
@@ -55,7 +33,7 @@ sys_fork_trampoline:
 
 	call read_ip
 	testq %rax, %rax
-	je .reload_stack
+	je .done
 
 	movq %rax, %rsi
 	movq %rsp, %rdi
@@ -69,9 +47,3 @@ sys_fork_trampoline:
 	popq %rbp
 	popq %rbx
 	ret
-
- .reload_stack:
-	call get_thread_start_sp
-	movq %rax, %rsp
-	xorq %rax, %rax
-	jmp .done

kernel/arch/x86_64/Thread.S

@@ -30,23 +30,6 @@ start_userspace_thread:
 	call get_thread_start_sp
 	movq %rax, %rsp
 
-	# STACK LAYOUT
-	#   entry
-	#   argc
-	#   argv
-	#   envp
-	#   userspace stack
+	swapgs
 
-	call get_userspace_thread_stack_top
-
-	popq %rdx
-	popq %rsi
-	popq %rdi
-	popq %rcx
-
-	pushq $(0x20 | 3)
-	pushq %rax
-	pushq $0x202
-	pushq $(0x18 | 3)
-	pushq %rcx
 	iretq

kernel/arch/x86_64/User.S

@@ -0,0 +1,87 @@
+# bool safe_user_memcpy(void*, const void*, size_t)
+.global safe_user_memcpy
+.global safe_user_memcpy_end
+.global safe_user_memcpy_fault
+safe_user_memcpy:
+	xorq %rax, %rax
+	movq %rdx, %rcx
+	rep movsb
+	incq %rax
+safe_user_memcpy_fault:
+	ret
+safe_user_memcpy_end:
+
+# bool safe_user_strncpy(void*, const void*, size_t)
+.global safe_user_strncpy
+.global safe_user_strncpy_end
+.global safe_user_strncpy_fault
+safe_user_strncpy:
+	movq %rdx, %rcx
+	testq %rcx, %rcx
+	jz safe_user_strncpy_fault
+
+ .safe_user_strncpy_align_loop:
+	testb $0x7, %sil
+	jz .safe_user_strncpy_align_done
+
+	movb (%rsi), %al
+	movb %al, (%rdi)
+	testb %al, %al
+	jz .safe_user_strncpy_done
+
+	incq %rdi
+	incq %rsi
+	decq %rcx
+	jnz .safe_user_strncpy_align_loop
+	jmp safe_user_strncpy_fault
+
+ .safe_user_strncpy_align_done:
+	movq $0x0101010101010101, %r8
+	movq $0x8080808080808080, %r9
+
+ .safe_user_strncpy_qword_loop:
+	cmpq $8, %rcx
+	jb .safe_user_strncpy_qword_done
+
+	movq (%rsi), %rax
+	movq %rax, %r10
+	movq %rax, %r11
+
+	# https://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord
+	subq %r8, %r10
+	notq %r11
+	andq %r11, %r10
+	andq %r9, %r10
+	jnz .safe_user_strncpy_byte_loop
+
+	movq %rax, (%rdi)
+
+	addq $8, %rdi
+	addq $8, %rsi
+	subq $8, %rcx
+	jnz .safe_user_strncpy_qword_loop
+	jmp safe_user_strncpy_fault
+
+ .safe_user_strncpy_qword_done:
+	testq %rcx, %rcx
+	jz safe_user_strncpy_fault
+
+ .safe_user_strncpy_byte_loop:
+	movb (%rsi), %al
+	movb %al, (%rdi)
+	testb %al, %al
+	jz .safe_user_strncpy_done
+
+	incq %rdi
+	incq %rsi
+	decq %rcx
+	jnz .safe_user_strncpy_byte_loop
+
+ safe_user_strncpy_fault:
+	xorq %rax, %rax
+	ret
+
+ .safe_user_strncpy_done:
+	movb $1, %al
+	ret
+safe_user_strncpy_end:

kernel/arch/x86_64/Yield.S

@@ -0,0 +1,29 @@
+.global asm_yield_trampoline
+asm_yield_trampoline:
+	leaq 8(%rsp), %rcx
+	movq %rdi, %rsp
+
+	subq $8, %rsp
+	pushq -8(%rcx)
+	pushq %rcx
+	pushq %rax
+	pushq %rbx
+	pushq %rbp
+	pushq %r12
+	pushq %r13
+	pushq %r14
+	pushq %r15
+
+	movq %rsp, %rdi
+	call scheduler_on_yield
+
+	popq %r15
+	popq %r14
+	popq %r13
+	popq %r12
+	popq %rbp
+	popq %rbx
+	popq %rax
+	movq 8(%rsp), %rcx
+	movq 0(%rsp), %rsp
+	jmp *%rcx

kernel/arch/x86_64/boot.S

@@ -14,6 +14,23 @@
 # multiboot2 header
 .section .multiboot, "aw"
 	.align 8
+multiboot_start:
+	.long 0x1BADB002
+	.long (1 << 2) # page align modules
+	.long -(0x1BADB002 + (1 << 2))
+
+	.long 0
+	.long 0
+	.long 0
+	.long 0
+	.long 0
+
+	.long 0
+	.long FB_WIDTH
+	.long FB_HEIGHT
+	.long FB_BPP
+multiboot_end:
+	.align 8
 multiboot2_start:
 	.long 0xE85250D6
 	.long 0
@@ -36,6 +53,12 @@ multiboot2_start:
 	.long 12
 	.long V2P(_start)
 
+	# page align modules
+	.align 8
+	.short 6
+	.short 0
+	.long 8
+
 	.align 8
 	.short 0
 	.short 0
@@ -53,9 +76,10 @@ bananboot_start:
 bananboot_end:
 
 .section .bss, "aw", @nobits
-	boot_stack_bottom:
-		.skip 4096 * 64
-	boot_stack_top:
+    .global g_boot_stack_top
+	g_boot_stack_bottom:
+		.skip 4096 * 4
+	g_boot_stack_top:
 
 	.global g_kernel_cmdline
 	g_kernel_cmdline:
@@ -108,9 +132,6 @@ g_ap_startup_done:
 .global g_ap_running_count
 g_ap_running_count:
 	.byte 0
-.global g_ap_stack_loaded
-g_ap_stack_loaded:
-	.byte 0
 
 .section .text
 
@@ -158,6 +179,13 @@ enable_sse:
 	movl %eax, %cr4
 	ret
 
+enable_tsc:
+	# allow userspace to use RDTSC
+	movl %cr4, %ecx
+	andl $0xFFFFFFFB, %ecx
+	movl %ecx, %cr4
+	ret
+
 initialize_paging:
 	# enable PAE
 	movl %cr4, %ecx
@@ -190,11 +218,11 @@ _start:
 	movl %eax, V2P(bootloader_magic)
 	movl %ebx, V2P(bootloader_info)
 
-	movl $V2P(boot_stack_top), %esp
+	movl $V2P(g_boot_stack_top), %esp
 
 	call check_requirements
 	call enable_sse
-
+	call enable_tsc
 	call initialize_paging
 
 	# flush gdt and jump to 64 bit
@@ -220,6 +248,13 @@ higher_half:
 	# call global constuctors
 	call _init
 
+	movq $g_init_array_start, %rbx
+	jmp 2f
+ 1: call *(%rbx)
+	addq $8, %rbx
+ 2: cmpq $g_init_array_end, %rbx
+	jne 1b
+
 	# call to the kernel itself (clear rbp for stacktrace)
 	xorq %rbp, %rbp
 
@@ -237,26 +272,31 @@ system_halt:
 	jmp 1b
 
 
+#define AP_V2P(vaddr) ((vaddr) - ap_trampoline + 0xF000)
+
 .section .ap_init, "ax"
 
 .code16
 .global ap_trampoline
 ap_trampoline:
 	jmp 1f
+
 .align 8
 ap_stack_ptr:
 	.skip 4
-1:
-	cli; cld
-	ljmpl $0x00, $ap_cs_clear
-ap_cs_clear:
+ap_stack_loaded:
+	.skip 1
 
+1:	cli; cld
+	ljmpl $0x00, $AP_V2P(ap_cs_clear)
+
+ap_cs_clear:
 	# load ap gdt and enter protected mode
-	lgdt ap_gdtr
+	lgdt AP_V2P(ap_gdtr)
 	movl %cr0, %eax
 	orb $1, %al
 	movl %eax, %cr0
-	ljmpl $0x08, $ap_protected_mode
+	ljmpl $0x08, $AP_V2P(ap_protected_mode)
 
 .code32
 ap_protected_mode:
@@ -265,16 +305,16 @@ ap_protected_mode:
 	movw %ax, %ss
 	movw %ax, %es
 
-	movl ap_stack_ptr, %esp
-	movb $1, V2P(g_ap_stack_loaded)
+	movl AP_V2P(ap_stack_ptr), %esp
+	movb $1, AP_V2P(ap_stack_loaded)
 
-	call V2P(enable_sse)
-
-	call V2P(initialize_paging)
+	leal V2P(enable_sse),        %ecx; call *%ecx
+	leal V2P(enable_tsc),        %ecx; call *%ecx
+	leal V2P(initialize_paging), %ecx; call *%ecx
 
 	# load boot gdt and enter long mode
 	lgdt V2P(boot_gdtr)
-	ljmpl $0x08, $ap_long_mode
+	ljmpl $0x08, $AP_V2P(ap_long_mode)
 
 .code64
 ap_long_mode:
@@ -282,22 +322,20 @@ ap_long_mode:
 	movl %esp, %esp
 	addq $KERNEL_OFFSET, %rsp
 
-	# jump to higher half
-	movabsq $ap_higher_half, %rcx
-	jmp *%rcx
-
-ap_higher_half:
 	# clear rbp for stacktrace
 	xorq %rbp, %rbp
 
+	xorb %al, %al
 1:	pause
-	cmpb $0, g_ap_startup_done
+	cmpb %al, g_ap_startup_done
 	jz 1b
 
 	lock incb g_ap_running_count
 
-	call ap_main
-	jmp system_halt
+	# jump to ap_main in higher half
+	movabsq $ap_main, %rcx
+	call *%rcx
+	jmp V2P(system_halt)
 
 ap_gdt:
 	.quad 0x0000000000000000 # null descriptor

kernel/arch/x86_64/interrupts.S

@@ -1,4 +1,12 @@
-.macro pushaq
+.macro swapgs_if_necessary, n
+	testb $3, \n(%rsp)
+	jz 1f; jnp 1f
+	swapgs
+1:
+.endm
+
+.macro pushaq, n
+	swapgs_if_necessary \n
 	pushq %rax
 	pushq %rcx
 	pushq %rdx
@@ -16,7 +24,7 @@
 	pushq %r15
 .endm
 
-.macro popaq
+.macro popaq, n
 	popq %r15
 	popq %r14
 	popq %r13
@@ -32,11 +40,12 @@
 	popq %rdx
 	popq %rcx
 	popq %rax
+	swapgs_if_necessary \n
 .endm
 
 isr_stub:
-	pushaq
-
+	pushaq 24
+	cld
 	movq %cr0, %rax; pushq %rax
 	movq %cr2, %rax; pushq %rax
 	movq %cr3, %rax; pushq %rax
@@ -49,25 +58,33 @@ isr_stub:
 	call cpp_isr_handler
 	addq $32, %rsp
 
-	popaq
+	popaq 24
 	addq $16, %rsp
 	iretq
 
 irq_stub:
-	pushaq
+	pushaq 24
+	cld
 	movq 120(%rsp), %rdi	# irq number
 	call cpp_irq_handler
-	popaq
+	popaq 24
 	addq $16, %rsp
 	iretq
 
-.global asm_yield_handler
-asm_yield_handler:
-	pushaq
-	leaq 120(%rsp), %rdi # interrupt stack ptr
-	movq     %rsp,  %rsi # interrupt register ptr
-	call cpp_yield_handler
-	popaq
+.global asm_ipi_handler
+asm_ipi_handler:
+	pushaq 8
+	cld
+	call cpp_ipi_handler
+	popaq 8
+	iretq
+
+.global asm_timer_handler
+asm_timer_handler:
+	pushaq 8
+	cld
+	call cpp_timer_handler
+	popaq 8
 	iretq
 
 .macro isr n
@@ -126,36 +143,26 @@ isr 29
 isr 30
 isr 31
 
-irq 0
-irq 1
-irq 2
-irq 3
-irq 4
-irq 5
-irq 6
-irq 7
-irq 8
-irq 9
-irq 10
-irq 11
-irq 12
-irq 13
-irq 14
-irq 15
-irq 16
-irq 17
-irq 18
-irq 19
-irq 20
-irq 21
-irq 22
-irq 23
-irq 24
-irq 25
-irq 26
-irq 27
-irq 28
-irq 29
-irq 30
-irq 31
-irq 32
+.irp i,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, \
+        10, 11, 12, 13, 14, 15, 16, 17, 18, 19, \
+        20, 21, 22, 23, 24, 25, 26, 27, 28, 29, \
+        30, 31, 32, 33, 34, 35, 36, 37, 38, 39, \
+        40, 41, 42, 43, 44, 45, 46, 47, 48, 49, \
+        50, 51, 52, 53, 54, 55, 56, 57, 58, 59, \
+        60, 61, 62, 63, 64, 65, 66, 67, 68, 69, \
+        70, 71, 72, 73, 74, 75, 76, 77, 78, 79, \
+        80, 81, 82, 83, 84, 85, 86, 87, 88, 89, \
+        90, 91, 92, 93, 94, 95, 96, 97, 98, 99, \
+       100,101,102,103,104,105,106,107,108,109, \
+       110,111,112,113,114,115,116,117,118,119, \
+       120,121,122,123,124,125,126,127,128,129, \
+       130,131,132,133,134,135,136,137,138,139, \
+       140,141,142,143,144,145,146,147,148,149, \
+       150,151,152,153,154,155,156,157,158,159, \
+       160,161,162,163,164,165,166,167,168,169, \
+       170,171,172,173,174,175,176,177,178,179, \
+       180,181,182,183,184,185,186,187,188,189, \
+       190,191,192,193,194,195,196,197,198,199, \
+       200,201,202,203,204,205,206,207
+	irq \i
+.endr

kernel/arch/x86_64/linker.ld

@@ -4,13 +4,6 @@ KERNEL_OFFSET = 0xFFFFFFFF80000000;
 
 SECTIONS
 {
-	. = 0xF000;
-	.ap_init ALIGN(4K) : AT(ADDR(.ap_init))
-	{
-		g_ap_init_addr = .;
-		*(.ap_init)
-	}
-
 	. = 0x00100000 + KERNEL_OFFSET;
 
 	g_kernel_start = .;
@@ -28,18 +21,31 @@ SECTIONS
 		g_userspace_end = .;
 		g_kernel_execute_end = .;
 	}
+	.ap_init ALIGN(4K) : AT(ADDR(.ap_init) - KERNEL_OFFSET)
+	{
+		g_ap_init_addr = .;
+		*(.ap_init)
+	}
 	.rodata ALIGN(4K) : AT(ADDR(.rodata) - KERNEL_OFFSET)
 	{
 		*(.rodata.*)
 	}
+	.init_array ALIGN(4K) : AT(ADDR(.init_array) - KERNEL_OFFSET)
+	{
+		g_init_array_start = .;
+		*(.init_array)
+		g_init_array_end = .;
+	}
 	.data ALIGN(4K) : AT(ADDR(.data) - KERNEL_OFFSET)
 	{
+		g_kernel_writable_start = .;
 		*(.data)
 	}
 	.bss ALIGN(4K) : AT(ADDR(.bss) - KERNEL_OFFSET)
 	{
 		*(COMMON)
 		*(.bss)
+		g_kernel_writable_end = .;
 	}
 	g_kernel_end = .;
 }

kernel/icxxabi.cpp

@@ -42,20 +42,20 @@ namespace __cxxabiv1
 {
 	using __guard = uint64_t;
 
-	int __cxa_guard_acquire (__guard* g)
+	extern "C" int __cxa_guard_acquire (__guard* g)
 	{
 		uint8_t* byte = reinterpret_cast<uint8_t*>(g);
 		uint8_t zero = 0;
 		return __atomic_compare_exchange_n(byte, &zero, 1, false, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);
 	}
 
-	void __cxa_guard_release (__guard* g)
+	extern "C" void __cxa_guard_release (__guard* g)
 	{
 		uint8_t* byte = reinterpret_cast<uint8_t*>(g);
 		__atomic_store_n(byte, 0, __ATOMIC_RELEASE);
 	}
 
-	void __cxa_guard_abort (__guard*)
+	extern "C" void __cxa_guard_abort (__guard*)
 	{
 		Kernel::panic("__cxa_guard_abort");
 	}

kernel/include/kernel/ACPI/ACPI.h

@@ -1,10 +1,11 @@
 #pragma once
 
 #include <BAN/Vector.h>
-#include <kernel/ACPI/AML/Method.h>
 #include <kernel/ACPI/AML/Namespace.h>
+#include <kernel/ACPI/EmbeddedController.h>
 #include <kernel/ACPI/Headers.h>
 #include <kernel/Memory/Types.h>
+#include <kernel/ThreadBlocker.h>
 
 namespace Kernel::ACPI
 {
@@ -28,25 +29,38 @@ namespace Kernel::ACPI
 		//   2: SAPIC
 		BAN::ErrorOr<void> enter_acpi_mode(uint8_t mode);
 
-		// This function will power off the system
-		// This function will return only if there was an error
-		void poweroff();
+		BAN::ErrorOr<void> initialize_acpi_devices();
 
-		// This function will reset the system
-		// This function will return only if there was an error
-		void reset();
+		AML::Namespace* acpi_namespace() { return m_namespace; }
+
+		BAN::ErrorOr<void> poweroff();
+		BAN::ErrorOr<void> reset();
+
+		BAN::ErrorOr<void> register_gpe_handler(uint8_t gpe, void (*callback)(void*), void* argument);
 
 		void handle_irq() override;
 
+		BAN::Span<BAN::UniqPtr<EmbeddedController>> embedded_controllers() { return m_embedded_controllers.span(); }
+
 	private:
 		ACPI() = default;
 		BAN::ErrorOr<void> initialize_impl();
 
 		FADT& fadt() { return *m_fadt; }
 
-		bool prepare_sleep(uint8_t sleep_state);
+		BAN::ErrorOr<void> prepare_sleep(uint8_t sleep_state);
 		void acpi_event_task();
 
+		BAN::ErrorOr<void> load_aml_tables(BAN::StringView name, bool all);
+
+		BAN::ErrorOr<void> route_interrupt_link_device(const AML::Scope& device, uint64_t& routed_irq_mask);
+
+		BAN::ErrorOr<void> initialize_embedded_controller(const AML::Scope& embedded_controller);
+		BAN::ErrorOr<void> initialize_embedded_controllers();
+
+		BAN::Optional<GAS> find_gpe_block(size_t index);
+		bool enable_gpe(uint8_t gpe);
+
 	private:
 		paddr_t m_header_table_paddr = 0;
 		vaddr_t m_header_table_vaddr = 0;
@@ -63,11 +77,28 @@ namespace Kernel::ACPI
 
 		FADT* m_fadt { nullptr };
 
-		Semaphore m_event_semaphore;
-		BAN::Array<BAN::RefPtr<AML::Method>, 0xFF> m_gpe_methods;
+		ThreadBlocker m_event_thread_blocker;
+
+		BAN::Vector<BAN::UniqPtr<EmbeddedController>> m_embedded_controllers;
+
+		struct GPEHandler
+		{
+			bool has_callback { false };
+			union {
+				AML::Reference* method;
+				struct
+				{
+					void (*callback)(void*);
+					void* argument;
+				};
+			};
+		};
+		bool m_has_any_gpes { false };
+		AML::Scope m_gpe_scope;
+		BAN::Array<GPEHandler, 0xFF> m_gpe_methods;
 
 		bool m_hardware_reduced { false };
-		BAN::RefPtr<AML::Namespace> m_namespace;
+		AML::Namespace* m_namespace { nullptr };
 	};
 
 }

kernel/include/kernel/ACPI/AML.h

@@ -1,11 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/Headers.h>
-#include <kernel/ACPI/AML/Namespace.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	BAN::RefPtr<AML::Namespace> initialize_namespace();
-
-}

kernel/include/kernel/ACPI/AML/Buffer.h

@@ -1,212 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/AML/Bytes.h>
-#include <kernel/ACPI/AML/Integer.h>
-#include <kernel/ACPI/AML/Node.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/ACPI/AML/Pkg.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct Buffer : public AML::Node
-	{
-		BAN::Vector<uint8_t> buffer;
-
-		Buffer()
-			: AML::Node(Node::Type::Buffer)
-		{}
-
-		BAN::RefPtr<AML::Node> evaluate() override
-		{
-			return this;
-		}
-
-		static ParseResult parse(AML::ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 1);
-			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::BufferOp);
-			context.aml_data = context.aml_data.slice(1);
-
-			auto buffer_pkg = AML::parse_pkg(context.aml_data);
-			if (!buffer_pkg.has_value())
-				return ParseResult::Failure;
-
-			auto buffer_context = context;
-			buffer_context.aml_data = buffer_pkg.value();
-
-			auto buffer_size_object = AML::parse_object(buffer_context);
-			if (!buffer_size_object.success())
-				return ParseResult::Failure;
-
-			auto buffer_size = buffer_size_object.node()->as_integer();
-			if (!buffer_size.has_value())
-				return ParseResult::Failure;
-
-			uint32_t actual_buffer_size = BAN::Math::max<uint32_t>(buffer_size.value(), buffer_context.aml_data.size());
-
-			auto buffer = MUST(BAN::RefPtr<Buffer>::create());
-			MUST(buffer->buffer.resize(actual_buffer_size, 0));
-			for (uint32_t i = 0; i < buffer_context.aml_data.size(); i++)
-					buffer->buffer[i] = buffer_context.aml_data[i];
-
-#if AML_DEBUG_LEVEL >= 2
-			buffer->debug_print(0);
-			AML_DEBUG_PRINTLN("");
-#endif
-
-			return ParseResult(buffer);
-		}
-
-		virtual void debug_print(int indent) const override
-		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("Buffer ({} bytes)", buffer.size());
-		}
-	};
-
-	struct BufferField : AML::NamedObject
-	{
-		BAN::RefPtr<Buffer> buffer;
-		size_t field_bit_offset;
-		size_t field_bit_size;
-
-		BufferField(AML::NameSeg name, BAN::RefPtr<Buffer> buffer, size_t field_bit_offset, size_t field_bit_size)
-			: AML::NamedObject(Node::Type::BufferField, name)
-			, buffer(buffer)
-			, field_bit_offset(field_bit_offset)
-			, field_bit_size(field_bit_size)
-		{}
-
-		BAN::RefPtr<AML::Node> evaluate() override
-		{
-			ASSERT(buffer);
-			ASSERT(field_bit_offset + field_bit_size <= buffer->buffer.size() * 8);
-
-			uint64_t value = 0;
-
-			const size_t byte_offset = field_bit_offset / 8;
-			const size_t bit_offset = field_bit_offset % 8;
-			if (field_bit_size == 1)
-			{
-				value = (buffer->buffer[byte_offset] >> bit_offset) & 1;
-			}
-			else
-			{
-				ASSERT(bit_offset == 0);
-				for (size_t byte = 0; byte < field_bit_size / 8; byte++)
-					value |= buffer->buffer[byte_offset + byte] << byte;
-			}
-
-			return MUST(BAN::RefPtr<AML::Integer>::create(value));
-		}
-
-		bool store(BAN::RefPtr<AML::Node> node) override
-		{
-			ASSERT(buffer);
-			ASSERT(field_bit_offset + field_bit_size <= buffer->buffer.size() * 8);
-
-			auto value = node->as_integer();
-			if (!value.has_value())
-				return false;
-
-			const size_t byte_offset = field_bit_offset / 8;
-			const size_t bit_offset = field_bit_offset % 8;
-			if (field_bit_size == 1)
-			{
-				buffer->buffer[byte_offset] &= ~(1 << bit_offset);
-				buffer->buffer[byte_offset] |= (value.value() & 1) << bit_offset;
-			}
-			else
-			{
-				ASSERT(bit_offset == 0);
-				for (size_t byte = 0; byte < field_bit_size / 8; byte++)
-					buffer->buffer[byte_offset + byte] = (value.value() >> (byte * 8)) & 0xFF;
-			}
-
-			return true;
-		}
-
-		static ParseResult parse(AML::ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 1);
-
-			size_t field_bit_size = 0;
-			switch (static_cast<Byte>(context.aml_data[0]))
-			{
-				case AML::Byte::CreateBitFieldOp:
-					field_bit_size = 1;
-					break;
-				case AML::Byte::CreateByteFieldOp:
-					field_bit_size = 8;
-					break;
-				case AML::Byte::CreateWordFieldOp:
-					field_bit_size = 16;
-					break;
-				case AML::Byte::CreateDWordFieldOp:
-					field_bit_size = 32;
-					break;
-				case AML::Byte::CreateQWordFieldOp:
-					field_bit_size = 64;
-					break;
-				default:
-					ASSERT_NOT_REACHED();
-			}
-			context.aml_data = context.aml_data.slice(1);
-
-			auto buffer_result = AML::parse_object(context);
-			if (!buffer_result.success())
-				return ParseResult::Failure;
-			auto buffer_node = buffer_result.node() ? buffer_result.node()->evaluate() : nullptr;
-			if (!buffer_node || buffer_node->type != Node::Type::Buffer)
-			{
-				AML_ERROR("Buffer source does not evaluate to a Buffer");
-				return ParseResult::Failure;
-			}
-			auto buffer = static_cast<Buffer*>(buffer_node.ptr());
-
-			auto index_result = AML::parse_object(context);
-			if (!index_result.success())
-				return ParseResult::Failure;
-			auto index = index_result.node() ? index_result.node()->as_integer() : BAN::Optional<uint64_t>();
-			if (!index.has_value())
-			{
-				AML_ERROR("Failed to parse index for BufferField");
-				return ParseResult::Failure;
-			}
-			size_t field_bit_offset = index.value();
-			if (field_bit_size != 1)
-				field_bit_offset *= 8;
-
-			auto field_name = AML::NameString::parse(context.aml_data);
-			if (!field_name.has_value())
-				return ParseResult::Failure;
-			if (field_name->path.empty())
-			{
-				AML_ERROR("Empty field name for BufferField");
-				return ParseResult::Failure;
-			}
-
-			auto field = MUST(BAN::RefPtr<BufferField>::create(field_name->path.back(), buffer, field_bit_offset, field_bit_size));
-			if (!Namespace::root_namespace()->add_named_object(context, field_name.value(), field))
-				return ParseResult::Failure;
-
-#if AML_DEBUG_LEVEL >= 2
-			field->debug_print(0);
-			AML_DEBUG_PRINTLN("");
-#endif
-
-			return ParseResult::Success;
-		}
-
-		virtual void debug_print(int indent) const override
-		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("BufferField {} at bit offset {} ({} bits) to { ", name, field_bit_offset, field_bit_size);
-			buffer->debug_print(0);
-			AML_DEBUG_PRINT(" }");
-		}
-
-	};
-
-}

kernel/include/kernel/ACPI/AML/Bytes.h

@@ -145,19 +145,35 @@ namespace Kernel::ACPI::AML
 		DataRegionOp = 0x88,
 	};
 
-	static constexpr bool is_digit_char(uint8_t ch)
+	inline constexpr bool is_digit_char(uint8_t ch)
 	{
 		return '0' <= ch && ch <= '9';
 	}
 
-	static constexpr bool is_lead_name_char(uint8_t ch)
+	inline constexpr bool is_lead_name_char(uint8_t ch)
 	{
 		return ('A' <= ch && ch <= 'Z') || ch == '_';
 	}
 
-	static constexpr bool is_name_char(uint8_t ch)
+	inline constexpr bool is_name_char(uint8_t ch)
 	{
 		return is_lead_name_char(ch) || is_digit_char(ch);
 	}
 
+	inline constexpr bool is_name_string_start(uint8_t ch)
+	{
+		if (is_lead_name_char(ch))
+			return true;
+		switch (static_cast<AML::Byte>(ch))
+		{
+			case AML::Byte::RootChar:
+			case AML::Byte::ParentPrefixChar:
+			case AML::Byte::MultiNamePrefix:
+			case AML::Byte::DualNamePrefix:
+				return true;
+			default:
+				return false;
+		}
+	}
+
 }

kernel/include/kernel/ACPI/AML/Device.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/AML/Method.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/ACPI/AML/Pkg.h>
-#include <kernel/ACPI/AML/Scope.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct Device : public AML::Scope
-	{
-		Device(NameSeg name)
-			: Scope(Node::Type::Device, name)
-		{}
-
-		static ParseResult parse(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 2);
-			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
-			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::DeviceOp);
-			context.aml_data = context.aml_data.slice(2);
-
-			auto device_pkg = AML::parse_pkg(context.aml_data);
-			if (!device_pkg.has_value())
-				return ParseResult::Failure;
-
-			auto name_string = AML::NameString::parse(device_pkg.value());
-			if (!name_string.has_value())
-				return ParseResult::Failure;
-
-			auto device = MUST(BAN::RefPtr<Device>::create(name_string->path.back()));
-			if (!Namespace::root_namespace()->add_named_object(context, name_string.value(), device))
-				return ParseResult::Failure;
-
-			return device->enter_context_and_parse_term_list(context, name_string.value(), device_pkg.value());
-		}
-
-		virtual void debug_print(int indent) const override
-		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("Device ");
-			name.debug_print();
-			AML_DEBUG_PRINTLN(" {");
-			Namespace::root_namespace()->for_each_child(scope,
-				[&](const auto&, const auto& child)
-				{
-					child->debug_print(indent + 1);
-					AML_DEBUG_PRINTLN("");
-				}
-			);
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("}");
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/Expression.h

@@ -1,216 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/AML/Bytes.h>
-#include <kernel/ACPI/AML/Integer.h>
-#include <kernel/ACPI/AML/Node.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct Expression
-	{
-		static ParseResult parse(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 1);
-			switch (static_cast<Byte>(context.aml_data[0]))
-			{
-				// unary
-				case AML::Byte::IncrementOp:
-				case AML::Byte::DecrementOp:
-				{
-					auto opcode = (static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::IncrementOp) ? AML::Byte::AddOp : AML::Byte::SubtractOp;
-					context.aml_data = context.aml_data.slice(1);
-
-					auto source_result = AML::parse_object(context);
-					if (!source_result.success())
-						return ParseResult::Failure;
-					auto source_node = source_result.node() ? source_result.node()->evaluate() : BAN::RefPtr<AML::Node>();
-					if (!source_node || source_node->type != AML::Node::Type::Integer)
-					{
-						AML_ERROR("UnaryOp source not integer");
-						return ParseResult::Failure;
-					}
-
-					auto source_integer = static_cast<AML::Integer*>(source_node.ptr());
-					if (source_integer->constant)
-					{
-						AML_ERROR("UnaryOp source is constant");
-						return ParseResult::Failure;
-					}
-
-					source_integer->value += (opcode == AML::Byte::AddOp) ? 1 : -1;
-					return ParseResult(source_integer);
-				}
-				case AML::Byte::NotOp:
-					AML_TODO("NotOp", context.aml_data[0]);
-					return ParseResult::Failure;
-				case AML::Byte::LNotOp:
-				{
-					context.aml_data = context.aml_data.slice(1);
-
-					auto node_result = AML::parse_object(context);
-					if (!node_result.success())
-						return ParseResult::Failure;
-
-					auto value = node_result.node() ? node_result.node()->as_integer() : BAN::Optional<uint64_t>();
-					if (!value.has_value())
-					{
-						AML_ERROR("Logical NotOp source is not integer");
-						return ParseResult::Failure;
-					}
-
-					auto result = value.value() ? Integer::Constants::Zero : Integer::Constants::Ones;
-					return ParseResult(result);
-				}
-				case AML::Byte::AddOp:
-				case AML::Byte::AndOp:
-				case AML::Byte::ModOp:
-				case AML::Byte::MultiplyOp:
-				case AML::Byte::NandOp:
-				case AML::Byte::NorOp:
-				case AML::Byte::OrOp:
-				case AML::Byte::ShiftLeftOp:
-				case AML::Byte::ShiftRightOp:
-				case AML::Byte::SubtractOp:
-				case AML::Byte::XorOp:
-					return parse_binary_op(context);
-				case AML::Byte::LAndOp:
-				case AML::Byte::LEqualOp:
-				case AML::Byte::LGreaterOp:
-				case AML::Byte::LLessOp:
-				case AML::Byte::LOrOp:
-					return parse_logical_binary_op(context);
-				case AML::Byte::DivideOp:
-					AML_TODO("DivideOp");
-					return ParseResult::Failure;
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-
-	private:
-		static ParseResult parse_binary_op(ParseContext& context)
-		{
-			auto opcode = static_cast<AML::Byte>(context.aml_data[0]);
-			context.aml_data = context.aml_data.slice(1);
-
-			auto lhs_result = AML::parse_object(context);
-			if (!lhs_result.success())
-				return ParseResult::Failure;
-			auto lhs_value = lhs_result.node() ? lhs_result.node()->as_integer() : BAN::Optional<uint64_t>();
-			if (!lhs_value.has_value())
-			{
-				AML_ERROR("BinaryOP {2H} LHS not an integer", static_cast<uint8_t>(opcode));
-				if (lhs_result.node())
-					lhs_result.node()->debug_print(1);
-				AML_DEBUG_PRINTLN("");
-				return ParseResult::Failure;
-			}
-
-			auto rhs_result = AML::parse_object(context);
-			if (!rhs_result.success())
-				return ParseResult::Failure;
-			auto rhs_value = lhs_result.node() ? rhs_result.node()->as_integer() : BAN::Optional<uint64_t>();
-			if (!rhs_value.has_value())
-			{
-				AML_ERROR("BinaryOP {2H} RHS not an integer", static_cast<uint8_t>(opcode));
-				if (rhs_result.node())
-					rhs_result.node()->debug_print(1);
-				AML_DEBUG_PRINTLN("");
-				return ParseResult::Failure;
-			}
-
-			if (context.aml_data.size() < 1)
-			{
-				AML_ERROR("BinaryOP {2H} missing target", static_cast<uint8_t>(opcode));
-				return ParseResult::Failure;
-			}
-			BAN::RefPtr<AML::Node> target_node;
-			if (context.aml_data[0] == 0x00)
-				context.aml_data = context.aml_data.slice(1);
-			else
-			{
-				auto target_result = AML::parse_object(context);
-				if (!target_result.success())
-					return ParseResult::Failure;
-				target_node = target_result.node();
-				if (!target_node)
-				{
-					AML_ERROR("BinaryOP {2H} target invalid", static_cast<uint8_t>(opcode));
-					return ParseResult::Failure;
-				}
-			}
-
-			uint64_t (*func)(uint64_t, uint64_t) = nullptr;
-			switch (opcode)
-			{
-				case AML::Byte::AddOp:			func = [](uint64_t a, uint64_t b) { return a + b; }; break;
-				case AML::Byte::AndOp:			func = [](uint64_t a, uint64_t b) { return a & b; }; break;
-				case AML::Byte::ModOp:			func = [](uint64_t a, uint64_t b) { return a % b; }; break;
-				case AML::Byte::MultiplyOp:		func = [](uint64_t a, uint64_t b) { return a * b; }; break;
-				case AML::Byte::NandOp:			func = [](uint64_t a, uint64_t b) { return ~(a & b); }; break;
-				case AML::Byte::NorOp:			func = [](uint64_t a, uint64_t b) { return ~(a | b); }; break;
-				case AML::Byte::OrOp:			func = [](uint64_t a, uint64_t b) { return a | b; }; break;
-				case AML::Byte::ShiftLeftOp:	func = [](uint64_t a, uint64_t b) { return a << b; }; break;
-				case AML::Byte::ShiftRightOp:	func = [](uint64_t a, uint64_t b) { return a >> b; }; break;
-				case AML::Byte::SubtractOp:		func = [](uint64_t a, uint64_t b) { return a - b; }; break;
-				case AML::Byte::XorOp:			func = [](uint64_t a, uint64_t b) { return a ^ b; }; break;
-				default:
-					ASSERT_NOT_REACHED();
-			}
-
-			uint64_t result = func(lhs_value.value(), rhs_value.value());
-			auto result_node = MUST(BAN::RefPtr<AML::Integer>::create(result));
-
-			if (target_node && !target_node->store(result_node))
-			{
-				AML_ERROR("BinaryOp {2H} failed to store result", static_cast<uint8_t>(opcode));
-				return ParseResult::Failure;
-			}
-
-			return ParseResult(result_node);
-		}
-
-		static ParseResult parse_logical_binary_op(ParseContext& context)
-		{
-			auto opcode = static_cast<AML::Byte>(context.aml_data[0]);
-			context.aml_data = context.aml_data.slice(1);
-
-			auto lhs_result = AML::parse_object(context);
-			if (!lhs_result.success())
-				return ParseResult::Failure;
-			auto lhs_value = lhs_result.node() ? lhs_result.node()->as_integer() : BAN::Optional<uint64_t>();
-			if (!lhs_value.has_value())
-			{
-				AML_TODO("Logical BinaryOP {2H} LHS not integer", static_cast<uint8_t>(opcode));
-				return ParseResult::Failure;
-			}
-
-			auto rhs_result = AML::parse_object(context);
-			if (!rhs_result.success())
-				return ParseResult::Failure;
-			auto rhs_value = rhs_result.node() ? rhs_result.node()->as_integer() : BAN::Optional<uint64_t>();
-			if (!rhs_value.has_value())
-			{
-				AML_TODO("Logical BinaryOP {2H} RHS not integer", static_cast<uint8_t>(opcode));
-				return ParseResult::Failure;
-			}
-
-			BAN::RefPtr<AML::Integer> (*func)(uint64_t, uint64_t) = nullptr;
-			switch (opcode)
-			{
-				case AML::Byte::LAndOp:			func = [](uint64_t a, uint64_t b) { return a && b ? Integer::Constants::Ones : Integer::Constants::Zero; }; break;
-				case AML::Byte::LEqualOp:		func = [](uint64_t a, uint64_t b) { return a == b ? Integer::Constants::Ones : Integer::Constants::Zero; }; break;
-				case AML::Byte::LGreaterOp:		func = [](uint64_t a, uint64_t b) { return a > b  ? Integer::Constants::Ones : Integer::Constants::Zero; }; break;
-				case AML::Byte::LLessOp:		func = [](uint64_t a, uint64_t b) { return a < b  ? Integer::Constants::Ones : Integer::Constants::Zero; }; break;
-				case AML::Byte::LOrOp:			func = [](uint64_t a, uint64_t b) { return a || b ? Integer::Constants::Ones : Integer::Constants::Zero; }; break;
-				default:
-					ASSERT_NOT_REACHED();
-			}
-
-			return ParseResult(func(lhs_value.value(), rhs_value.value()));
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/Field.h

@@ -1,141 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/AML/NamedObject.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/ACPI/AML/Pkg.h>
-#include <kernel/ACPI/AML/Region.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct FieldRules
-	{
-		enum class AccessType
-		{
-			Any = 0,
-			Byte = 1,
-			Word = 2,
-			DWord = 3,
-			QWord = 4,
-			Buffer = 5,
-		};
-		AccessType access_type;
-
-		enum class LockRule
-		{
-			NoLock = 0,
-			Lock = 1,
-		};
-		LockRule lock_rule;
-
-		enum class UpdateRule
-		{
-			Preserve = 0,
-			WriteAsOnes = 1,
-			WriteAsZeros = 2,
-		};
-		UpdateRule update_rule;
-
-		enum class AccessAttrib
-		{
-			Normal = 0,
-			Bytes = 1,
-			RawBytes = 2,
-			RawProcessBytes = 3,
-		};
-		AccessAttrib access_attrib = AccessAttrib::Normal;
-		uint8_t access_length = 0;
-	};
-
-	struct FieldElement : public NamedObject
-	{
-		uint64_t bit_offset;
-		uint64_t bit_count;
-
-		FieldRules access_rules;
-
-		BAN::RefPtr<OpRegion> op_region;
-
-		FieldElement(NameSeg name, uint64_t bit_offset, uint64_t bit_count, FieldRules access_rules)
-			: NamedObject(Node::Type::FieldElement, name)
-			, bit_offset(bit_offset)
-			, bit_count(bit_count)
-			, access_rules(access_rules)
-		{}
-
-		BAN::RefPtr<Node> evaluate() override;
-		bool store(BAN::RefPtr<Node> source) override;
-
-		void debug_print(int indent) const override;
-
-	private:
-		BAN::Optional<uint64_t> evaluate_internal();
-		bool store_internal(uint64_t value);
-
-		friend struct IndexFieldElement;
-		friend struct BankFieldElement;
-	};
-
-	struct Field
-	{
-		static ParseResult parse(ParseContext& context);
-	};
-
-	struct IndexFieldElement : public NamedObject
-	{
-		uint64_t bit_offset;
-		uint64_t bit_count;
-
-		FieldRules access_rules;
-
-		BAN::RefPtr<FieldElement> index_element;
-		BAN::RefPtr<FieldElement> data_element;
-
-		IndexFieldElement(NameSeg name, uint64_t bit_offset, uint64_t bit_count, FieldRules access_rules)
-			: NamedObject(Node::Type::IndexFieldElement, name)
-			, bit_offset(bit_offset)
-			, bit_count(bit_count)
-			, access_rules(access_rules)
-		{}
-
-		BAN::RefPtr<Node> evaluate() override;
-		bool store(BAN::RefPtr<Node> source) override;
-
-		void debug_print(int indent) const override;
-	};
-
-	struct IndexField
-	{
-		static ParseResult parse(ParseContext& context);
-	};
-
-	struct BankFieldElement : public NamedObject
-	{
-		uint64_t bit_offset;
-		uint64_t bit_count;
-
-		FieldRules access_rules;
-
-		BAN::RefPtr<OpRegion> op_region;
-		BAN::RefPtr<FieldElement> bank_selector;
-		uint64_t bank_value;
-
-		BankFieldElement(NameSeg name, uint64_t bit_offset, uint64_t bit_count, FieldRules access_rules)
-			: NamedObject(Node::Type::BankFieldElement, name)
-			, bit_offset(bit_offset)
-			, bit_count(bit_count)
-			, access_rules(access_rules)
-		{}
-
-		BAN::RefPtr<Node> evaluate() override;
-		bool store(BAN::RefPtr<Node> source) override;
-
-		void debug_print(int indent) const override;
-	};
-
-	struct BankField
-	{
-		static ParseResult parse(ParseContext& context);
-	};
-
-}

kernel/include/kernel/ACPI/AML/IfElse.h

@@ -1,64 +0,0 @@
-#pragma once
-
-#include <BAN/HashMap.h>
-#include <kernel/ACPI/AML/Node.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/ACPI/AML/Pkg.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct IfElse
-	{
-		static ParseResult parse(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 1);
-			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::IfOp);
-			context.aml_data = context.aml_data.slice(1);
-
-			auto if_pkg = AML::parse_pkg(context.aml_data);
-			if (!if_pkg.has_value())
-				return ParseResult::Failure;
-
-			auto outer_aml_data = context.aml_data;
-			context.aml_data = if_pkg.value();
-
-			auto predicate_result = AML::parse_object(context);
-			if (!predicate_result.success())
-				return ParseResult::Failure;
-			auto predicate = predicate_result.node() ? predicate_result.node()->as_integer() : BAN::Optional<uint64_t>();
-			if (!predicate.has_value())
-			{
-				AML_ERROR("If predicate is not an integer");
-				return ParseResult::Failure;
-			}
-
-			// Else
-			BAN::ConstByteSpan else_pkg;
-			if (outer_aml_data.size() >= 1 && static_cast<AML::Byte>(outer_aml_data[0]) == Byte::ElseOp)
-			{
-				outer_aml_data = outer_aml_data.slice(1);
-				auto else_pkg_result = AML::parse_pkg(outer_aml_data);
-				if (!else_pkg_result.has_value())
-					return ParseResult::Failure;
-				else_pkg = else_pkg_result.value();
-			}
-			if (!predicate.value())
-				context.aml_data = else_pkg;
-
-			while (context.aml_data.size() > 0)
-			{
-				auto object_result = AML::parse_object(context);
-				if (object_result.returned())
-					return ParseResult(ParseResult::Result::Returned, object_result.node());
-				if (!object_result.success())
-					return ParseResult::Failure;
-			}
-
-			context.aml_data = outer_aml_data;
-
-			return ParseResult::Success;
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/Index.h

@@ -1,106 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/AML/Buffer.h>
-#include <kernel/ACPI/AML/Node.h>
-#include <kernel/ACPI/AML/Package.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/ACPI/AML/Reference.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct Index
-	{
-		static ParseResult parse(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 1);
-			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::IndexOp);
-			context.aml_data = context.aml_data.slice(1);
-
-			auto source_result = AML::parse_object(context);
-			if (!source_result.success())
-				return ParseResult::Failure;
-			auto source = source_result.node() ? source_result.node()->evaluate() : BAN::RefPtr<AML::Node>();
-			if (!source)
-			{
-				AML_ERROR("IndexOp source is null");
-				return ParseResult::Failure;
-			}
-
-			auto index_result = AML::parse_object(context);
-			if (!index_result.success())
-				return ParseResult::Failure;
-			auto index = index_result.node() ? index_result.node()->as_integer() : BAN::Optional<uint64_t>();
-			if (!index.has_value())
-			{
-				AML_ERROR("IndexOp index is not an integer");
-				return ParseResult::Failure;
-			}
-
-			BAN::RefPtr<AML::Reference> result;
-			switch (source->type)
-			{
-				case AML::Node::Type::Buffer:
-				{
-					auto buffer = static_cast<AML::Buffer*>(source.ptr());
-					if (index.value() >= buffer->buffer.size())
-					{
-						AML_ERROR("IndexOp index is out of buffer bounds");
-						return ParseResult::Failure;
-					}
-					auto buffer_field = MUST(BAN::RefPtr<BufferField>::create(NameSeg(""sv), buffer, index.value() * 8, 8));
-					result = MUST(BAN::RefPtr<AML::Reference>::create(buffer_field));
-					break;
-				}
-				case AML::Node::Type::Package:
-				{
-					auto package = static_cast<AML::Package*>(source.ptr());
-					if (index.value() >= package->elements.size())
-					{
-						AML_ERROR("IndexOp index is out of package bounds");
-						return ParseResult::Failure;
-					}
-					auto package_element = package->elements[index.value()];
-					result = MUST(BAN::RefPtr<AML::Reference>::create(package_element));
-					break;
-				}
-				case AML::Node::Type::String:
-					AML_TODO("IndexOp source String");
-					return ParseResult::Failure;
-				default:
-					AML_ERROR("IndexOp source is not a Buffer, Package, or String");
-					return ParseResult::Failure;
-			}
-
-#if AML_DEBUG_LEVEL >= 2
-			AML_DEBUG_PRINT("Index {}, ", index.value());
-			source->debug_print(0);
-			AML_DEBUG_PRINTLN("");
-#endif
-
-			if (context.aml_data.size() < 1)
-				return ParseResult::Failure;
-
-			if (context.aml_data[0] == 0x00)
-				context.aml_data = context.aml_data.slice(1);
-			else
-			{
-				auto destination_result = AML::parse_object(context);
-				if (!destination_result.success())
-					return ParseResult::Failure;
-				auto destination = destination_result.node();
-				if (!destination)
-				{
-					AML_ERROR("IndexOp failed to resolve destination");
-					return ParseResult::Failure;
-				}
-
-				if (!destination->store(result))
-					return ParseResult::Failure;
-			}
-
-			return ParseResult(result);
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/Integer.h

@@ -1,131 +0,0 @@
-#pragma once
-
-#include <BAN/Endianness.h>
-#include <BAN/Optional.h>
-#include <BAN/String.h>
-#include <BAN/Vector.h>
-#include <kernel/ACPI/AML/Bytes.h>
-#include <kernel/ACPI/AML/Node.h>
-#include <kernel/ACPI/AML/Utils.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct Integer : public Node
-	{
-		struct Constants
-		{
-			// Initialized in Namespace::create_root_namespace
-			static BAN::RefPtr<Integer> Zero;
-			static BAN::RefPtr<Integer> One;
-			static BAN::RefPtr<Integer> Ones;
-		};
-
-		const bool constant;
-		uint64_t value;
-
-		Integer(uint64_t value, bool constant = false)
-			: Node(Node::Type::Integer)
-			, value(value)
-			, constant(constant)
-		{}
-
-		BAN::RefPtr<AML::Node> evaluate() override
-		{
-			return this;
-		}
-
-		bool store(BAN::RefPtr<AML::Node> store_node) override
-		{
-			if (constant)
-			{
-				AML_ERROR("Cannot store to constant integer");
-				return false;
-			}
-			auto store_value = store_node->as_integer();
-			if (!store_value.has_value())
-			{
-				AML_ERROR("Cannot store non-integer to integer");
-				return false;
-			}
-			value = store_value.value();
-			return true;
-		}
-
-		static ParseResult parse(BAN::ConstByteSpan& aml_data)
-		{
-			switch (static_cast<AML::Byte>(aml_data[0]))
-			{
-				case AML::Byte::ZeroOp:
-					aml_data = aml_data.slice(1);
-					return ParseResult(Constants::Zero);
-				case AML::Byte::OneOp:
-					aml_data = aml_data.slice(1);
-					return ParseResult(Constants::One);
-				case AML::Byte::OnesOp:
-					aml_data = aml_data.slice(1);
-					return ParseResult(Constants::Ones);
-				case AML::Byte::BytePrefix:
-				{
-					if (aml_data.size() < 2)
-						return ParseResult::Failure;
-					uint8_t value = aml_data[1];
-					aml_data = aml_data.slice(2);
-					return ParseResult(MUST(BAN::RefPtr<Integer>::create(value)));
-				}
-				case AML::Byte::WordPrefix:
-				{
-					if (aml_data.size() < 3)
-						return ParseResult::Failure;
-					uint16_t value = BAN::little_endian_to_host<uint16_t>(
-						*reinterpret_cast<const uint16_t*>(&aml_data[1])
-					);
-					aml_data = aml_data.slice(3);
-					return ParseResult(MUST(BAN::RefPtr<Integer>::create(value)));
-				}
-				case AML::Byte::DWordPrefix:
-				{
-					if (aml_data.size() < 5)
-						return ParseResult::Failure;
-					uint32_t value = BAN::little_endian_to_host<uint32_t>(
-						*reinterpret_cast<const uint32_t*>(&aml_data[1])
-					);
-					aml_data = aml_data.slice(5);
-					return ParseResult(MUST(BAN::RefPtr<Integer>::create(value)));
-				}
-				case AML::Byte::QWordPrefix:
-				{
-					if (aml_data.size() < 9)
-						return ParseResult::Failure;
-					uint64_t value = BAN::little_endian_to_host<uint64_t>(
-						*reinterpret_cast<const uint64_t*>(&aml_data[1])
-					);
-					aml_data = aml_data.slice(9);
-					return ParseResult(MUST(BAN::RefPtr<Integer>::create(value)));
-				}
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-
-		void debug_print(int indent) const override
-		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			if (!constant)
-				AML_DEBUG_PRINT("0x{H}", value);
-			else
-			{
-				AML_DEBUG_PRINT("Const ");
-				if (value == Constants::Zero->value)
-					AML_DEBUG_PRINT("Zero");
-				else if (value == Constants::One->value)
-					AML_DEBUG_PRINT("One");
-				else if (value == Constants::Ones->value)
-					AML_DEBUG_PRINT("Ones");
-				else
-					ASSERT_NOT_REACHED();
-			}
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/Method.h

@@ -1,175 +0,0 @@
-#pragma once
-
-#include <BAN/Function.h>
-#include <kernel/ACPI/AML/Bytes.h>
-#include <kernel/ACPI/AML/Namespace.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/ACPI/AML/Pkg.h>
-#include <kernel/ACPI/AML/Scope.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct Method : public AML::Scope
-	{
-		Kernel::Mutex mutex;
-		uint8_t arg_count;
-		bool serialized;
-		uint8_t sync_level;
-
-		BAN::Function<BAN::RefPtr<AML::Node>(ParseContext&)> override_function;
-		BAN::ConstByteSpan term_list;
-
-		Method(AML::NameSeg name, uint8_t arg_count, bool serialized, uint8_t sync_level)
-			: AML::Scope(Node::Type::Method, name)
-			, arg_count(arg_count)
-			, serialized(serialized)
-			, sync_level(sync_level)
-		{}
-
-		static ParseResult parse(AML::ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 1);
-			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::MethodOp);
-			context.aml_data = context.aml_data.slice(1);
-
-			auto method_pkg = AML::parse_pkg(context.aml_data);
-			if (!method_pkg.has_value())
-				return ParseResult::Failure;
-
-			auto name_string = AML::NameString::parse(method_pkg.value());
-			if (!name_string.has_value())
-				return ParseResult::Failure;
-
-			if (method_pkg->size() < 1)
-				return ParseResult::Failure;
-			auto method_flags = method_pkg.value()[0];
-			method_pkg = method_pkg.value().slice(1);
-
-			auto method = MUST(BAN::RefPtr<Method>::create(
-				name_string.value().path.back(),
-				method_flags & 0x07,
-				(method_flags >> 3) & 0x01,
-				method_flags >> 4
-			));
-			if (!Namespace::root_namespace()->add_named_object(context, name_string.value(), method))
-				return ParseResult::Failure;
-			method->term_list = method_pkg.value();
-
-#if AML_DEBUG_LEVEL >= 2
-			method->debug_print(0);
-			AML_DEBUG_PRINTLN("");
-#endif
-
-			return ParseResult::Success;
-		}
-
-		BAN::Optional<BAN::RefPtr<AML::Node>> invoke(
-			BAN::RefPtr<AML::Node> arg0 = {},
-			BAN::RefPtr<AML::Node> arg1 = {},
-			BAN::RefPtr<AML::Node> arg2 = {},
-			BAN::RefPtr<AML::Node> arg3 = {},
-			BAN::RefPtr<AML::Node> arg4 = {},
-			BAN::RefPtr<AML::Node> arg5 = {},
-			BAN::RefPtr<AML::Node> arg6 = {}
-		)
-		{
-			BAN::Vector<uint8_t> sync_stack;
-			return invoke_with_sync_stack(sync_stack, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
-		}
-
-		BAN::Optional<BAN::RefPtr<AML::Node>> invoke_with_sync_stack(
-			BAN::Vector<uint8_t>& current_sync_stack,
-			BAN::RefPtr<AML::Node> arg0 = {},
-			BAN::RefPtr<AML::Node> arg1 = {},
-			BAN::RefPtr<AML::Node> arg2 = {},
-			BAN::RefPtr<AML::Node> arg3 = {},
-			BAN::RefPtr<AML::Node> arg4 = {},
-			BAN::RefPtr<AML::Node> arg5 = {},
-			BAN::RefPtr<AML::Node> arg6 = {}
-		)
-		{
-			if (serialized && !current_sync_stack.empty() && sync_level < current_sync_stack.back())
-			{
-				AML_ERROR("Trying to evaluate method {} with lower sync level than current sync level", scope);
-				return {};
-			}
-
-			ParseContext context;
-			context.aml_data = term_list;
-			context.scope = scope;
-			context.method_args[0] = MUST(BAN::RefPtr<AML::Register>::create(arg0));
-			context.method_args[1] = MUST(BAN::RefPtr<AML::Register>::create(arg1));
-			context.method_args[2] = MUST(BAN::RefPtr<AML::Register>::create(arg2));
-			context.method_args[3] = MUST(BAN::RefPtr<AML::Register>::create(arg3));
-			context.method_args[4] = MUST(BAN::RefPtr<AML::Register>::create(arg4));
-			context.method_args[5] = MUST(BAN::RefPtr<AML::Register>::create(arg5));
-			context.method_args[6] = MUST(BAN::RefPtr<AML::Register>::create(arg6));
-			context.sync_stack = BAN::move(current_sync_stack);
-			for (auto& local : context.method_locals)
-				local = MUST(BAN::RefPtr<AML::Register>::create());
-
-			if (serialized)
-			{
-				mutex.lock();
-				MUST(context.sync_stack.push_back(sync_level));
-			}
-
-#if AML_DEBUG_LEVEL >= 2
-			AML_DEBUG_PRINTLN("Evaluating {}", scope);
-#endif
-
-			BAN::Optional<BAN::RefPtr<AML::Node>> return_value = BAN::RefPtr<AML::Node>();
-
-			if (override_function)
-				return_value = override_function(context);
-			else
-			{
-				while (context.aml_data.size() > 0)
-				{
-					auto parse_result = AML::parse_object(context);
-					if (parse_result.returned())
-					{
-						return_value = parse_result.node();
-						break;
-					}
-					if (!parse_result.success())
-					{
-						AML_ERROR("Method {} evaluate failed", scope);
-						return_value = {};
-						break;
-					}
-				}
-			}
-
-			while (!context.created_objects.empty())
-			{
-				Namespace::root_namespace()->remove_named_object(context.created_objects.back());
-				context.created_objects.pop_back();
-			}
-
-			if (serialized)
-			{
-				context.sync_stack.pop_back();
-				mutex.unlock();
-			}
-
-			current_sync_stack = BAN::move(context.sync_stack);
-
-			return return_value;
-		}
-
-		virtual void debug_print(int indent) const override
-		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("Method ");
-			name.debug_print();
-			AML_DEBUG_PRINTLN("({} args, {}Serialized, 0x{H}) {", arg_count, serialized ? "" : "Not", sync_level);
-			AML_DEBUG_PRINT_INDENT(indent + 1);
-			AML_DEBUG_PRINTLN("TermList: {} bytes", term_list.size());
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("}");
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/Mutex.h

@@ -1,166 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/AML/Bytes.h>
-#include <kernel/ACPI/AML/Integer.h>
-#include <kernel/ACPI/AML/NamedObject.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/Lock/Mutex.h>
-#include <kernel/Timer/Timer.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct Mutex : public AML::NamedObject
-	{
-		Kernel::Mutex mutex;
-		uint8_t sync_level;
-
-		Mutex(NameSeg name, uint8_t sync_level)
-			: NamedObject(Node::Type::Mutex, name)
-			, sync_level(sync_level)
-		{}
-
-		static ParseResult parse(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 2);
-			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
-
-			switch (static_cast<AML::ExtOp>(context.aml_data[1]))
-			{
-				case AML::ExtOp::MutexOp:
-					return parse_mutex(context);
-				case AML::ExtOp::AcquireOp:
-					return parse_acquire(context);
-				case AML::ExtOp::ReleaseOp:
-					return parse_release(context);
-				default:
-					ASSERT_NOT_REACHED();
-			}
-		}
-
-		virtual void debug_print(int indent) const override
-		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("Mutex ");
-			name.debug_print();
-			AML_DEBUG_PRINT(" (SyncLevel: {})", sync_level);
-		}
-
-	private:
-		static ParseResult parse_mutex(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 2);
-			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
-			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::MutexOp);
-			context.aml_data = context.aml_data.slice(2);
-
-			auto name = NameString::parse(context.aml_data);
-			if (!name.has_value())
-				return ParseResult::Failure;
-
-			if (context.aml_data.size() < 1)
-				return ParseResult::Failure;
-			auto sync_level = context.aml_data[0];
-			context.aml_data = context.aml_data.slice(1);
-
-			if (sync_level & 0xF0)
-			{
-				AML_ERROR("Invalid sync level {}", sync_level);
-				return ParseResult::Failure;
-			}
-
-			auto mutex = MUST(BAN::RefPtr<Mutex>::create(name->path.back(), sync_level));
-			if (!Namespace::root_namespace()->add_named_object(context, name.value(), mutex))
-				return ParseResult::Failure;
-
-#if AML_DEBUG_LEVEL >= 2
-			mutex->debug_print(0);
-			AML_DEBUG_PRINTLN("");
-#endif
-
-			return ParseResult::Success;
-		}
-
-		static ParseResult parse_acquire(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 2);
-			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
-			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::AcquireOp);
-			context.aml_data = context.aml_data.slice(2);
-
-			auto mutex_result = AML::parse_object(context);
-			if (!mutex_result.success() || !mutex_result.node() || mutex_result.node()->type != AML::Node::Type::Mutex)
-			{
-				AML_ERROR("Acquire does not name a valid mutex");
-				return ParseResult::Failure;
-			}
-
-			auto* mutex = static_cast<AML::Mutex*>(mutex_result.node().ptr());
-			if (mutex->sync_level < context.sync_level())
-			{
-				AML_ERROR("Trying to acquire mutex with lower sync level than current sync level");
-				return ParseResult::Failure;
-			}
-
-			if (context.aml_data.size() < 2)
-			{
-				AML_ERROR("Missing timeout value");
-				return ParseResult::Failure;
-			}
-			uint16_t timeout = context.aml_data[0] | (context.aml_data[1] << 8);
-			context.aml_data = context.aml_data.slice(2);
-
-			if (timeout >= 0xFFFF)
-				mutex->mutex.lock();
-			else
-			{
-				// FIXME: This is a very inefficient way to wait for a mutex
-				uint64_t wake_time = SystemTimer::get().ms_since_boot() + timeout;
-				while (!mutex->mutex.try_lock())
-				{
-					if (SystemTimer::get().ms_since_boot() >= wake_time)
-						return ParseResult(Integer::Constants::Ones);
-					SystemTimer::get().sleep(1);
-				}
-			}
-
-			MUST(context.sync_stack.push_back(mutex->sync_level));
-			return ParseResult(Integer::Constants::Zero);
-		}
-
-		static ParseResult parse_release(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 2);
-			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
-			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::ReleaseOp);
-			context.aml_data = context.aml_data.slice(2);
-
-			auto mutex_result = AML::parse_object(context);
-			if (!mutex_result.success() || !mutex_result.node() || mutex_result.node()->type != AML::Node::Type::Mutex)
-			{
-				AML_ERROR("Release does not name a valid mutex");
-				return ParseResult::Failure;
-			}
-
-			if (context.sync_stack.empty())
-			{
-				AML_ERROR("Trying to release mutex without having acquired it");
-				return ParseResult::Failure;
-			}
-
-			auto* mutex = static_cast<AML::Mutex*>(mutex_result.node().ptr());
-			if (mutex->sync_level != context.sync_level())
-			{
-				AML_ERROR("Trying to release mutex with different sync level than current sync level");
-				return ParseResult::Failure;
-			}
-
-			mutex->mutex.unlock();
-			context.sync_stack.pop_back();
-
-			return ParseResult::Success;
-		}
-
-	};
-
-}

kernel/include/kernel/ACPI/AML/NamedObject.h

@@ -1,42 +0,0 @@
-#pragma once
-
-#include <BAN/HashMap.h>
-#include <kernel/ACPI/AML/Names.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct NamedObject : public Node
-	{
-		BAN::RefPtr<NamedObject> parent;
-		NameSeg name;
-
-		NamedObject(Node::Type type, NameSeg name) : Node(type), name(name) {}
-	};
-
-	struct Name : public NamedObject
-	{
-		BAN::RefPtr<AML::Node> object;
-
-		Name(NameSeg name, BAN::RefPtr<AML::Node> object)
-			: NamedObject(Node::Type::Name, name), object(BAN::move(object))
-		{}
-
-		BAN::RefPtr<AML::Node> evaluate() override
-		{
-			ASSERT(object);
-			return object->evaluate();
-		}
-
-		bool store(BAN::RefPtr<AML::Node> node) override
-		{
-			ASSERT(object);
-			object = node;
-			return true;
-		}
-
-		static ParseResult parse(ParseContext& context);
-		virtual void debug_print(int indent) const override;
-	};
-
-}

kernel/include/kernel/ACPI/AML/Names.h

@@ -1,241 +0,0 @@
-#pragma once
-
-#include <BAN/Optional.h>
-#include <BAN/String.h>
-#include <BAN/Vector.h>
-#include <kernel/ACPI/AML/Bytes.h>
-#include <kernel/ACPI/AML/Node.h>
-#include <kernel/ACPI/AML/Utils.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct NameSeg
-	{
-		union {
-			char chars[4];
-			uint32_t u32;
-		};
-
-		NameSeg() = default;
-
-		NameSeg(BAN::StringView name)
-		{
-			ASSERT(name.size() <= 4);
-			for (size_t i = 0; i < name.size(); i++)
-				chars[i] = static_cast<char>(name[i]);
-			for (size_t i = name.size(); i < 4; i++)
-				chars[i] = '_';
-		}
-
-		NameSeg(BAN::ConstByteSpan& aml_data)
-		{
-			ASSERT(aml_data.size() >= 4);
-			for (size_t i = 0; i < 4; i++)
-				chars[i] = static_cast<char>(aml_data[i]);
-			aml_data = aml_data.slice(4);
-		}
-
-		BAN::StringView sv() const
-		{
-			size_t len = 4;
-			while (len > 0 && chars[len - 1] == '_')
-				len--;
-			return BAN::StringView(chars, len);
-		}
-
-		static BAN::Optional<NameSeg> parse(BAN::ConstByteSpan& aml_data)
-		{
-			if (aml_data.size() < 4)
-				return {};
-
-			if (!is_lead_name_char(aml_data[0])
-				|| !is_name_char(aml_data[1])
-				|| !is_name_char(aml_data[2])
-				|| !is_name_char(aml_data[3]))
-				return {};
-
-			return NameSeg(aml_data);
-		}
-
-		constexpr bool operator==(const NameSeg& other) const
-		{
-			return u32 == other.u32;
-		}
-
-		void debug_print() const
-		{
-			size_t len = 4;
-			while (len > 0 && chars[len - 1] == '_')
-				len--;
-			for (size_t i = 0; i < len; i++)
-				AML_DEBUG_PUTC(chars[i]);
-		}
-	};
-
-	struct NameString
-	{
-		BAN::String prefix;
-		BAN::Vector<NameSeg> path;
-
-		NameString() = default;
-		NameString(BAN::StringView str)
-		{
-			if (!str.empty() && str.front() == '\\')
-			{
-				MUST(prefix.push_back('\\'));
-				str = str.substring(1);
-			}
-			else
-			{
-				while (str.size() > 0 && str.front() == '^')
-				{
-					MUST(prefix.push_back('^'));
-					str = str.substring(1);
-				}
-			}
-
-			while (!str.empty())
-			{
-				ASSERT(str[0] != '.');
-				size_t len = 1;
-				while (len < str.size() && str[len] != '.')
-					len++;
-				ASSERT(len <= 4);
-
-				MUST(path.push_back(NameSeg(str.substring(0, len))));
-				str = str.substring(len);
-
-				if (!str.empty())
-				{
-					ASSERT(str[0] == '.');
-					str = str.substring(1);
-				}
-			}
-		}
-
-		static bool can_parse(BAN::ConstByteSpan aml_data)
-		{
-			if (aml_data.size() == 0)
-				return false;
-			switch (static_cast<AML::Byte>(aml_data[0]))
-			{
-				case AML::Byte::RootChar:
-				case AML::Byte::ParentPrefixChar:
-				case AML::Byte::NullName:
-				case AML::Byte::DualNamePrefix:
-				case AML::Byte::MultiNamePrefix:
-					return true;
-				default:
-					return is_lead_name_char(aml_data[0]);
-			}
-		}
-
-		static BAN::Optional<NameString> parse(BAN::ConstByteSpan& aml_data)
-		{
-			if (aml_data.size() == 0)
-				return {};
-
-			NameString result;
-
-			if (static_cast<AML::Byte>(aml_data[0]) == AML::Byte::RootChar)
-			{
-				MUST(result.prefix.push_back('\\'));
-				aml_data = aml_data.slice(1);
-			}
-			else
-			{
-				while (aml_data.size() > 0 && static_cast<AML::Byte>(aml_data[0]) == AML::Byte::ParentPrefixChar)
-				{
-					MUST(result.prefix.push_back(aml_data[0]));
-					aml_data = aml_data.slice(1);
-				}
-			}
-
-			if (aml_data.size() == 0)
-				return {};
-
-			size_t name_count = 1;
-			switch (static_cast<AML::Byte>(aml_data[0]))
-			{
-				case AML::Byte::NullName:
-					name_count = 0;
-					aml_data = aml_data.slice(1);
-					break;
-				case AML::Byte::DualNamePrefix:
-					name_count = 2;
-					aml_data = aml_data.slice(1);
-					break;
-				case AML::Byte::MultiNamePrefix:
-					if (aml_data.size() < 2)
-						return {};
-					name_count = aml_data[1];
-					aml_data = aml_data.slice(2);
-					break;
-				default:
-					break;
-			}
-
-			for (size_t i = 0; i < name_count; i++)
-			{
-				auto name_seg = NameSeg::parse(aml_data);
-				if (!name_seg.has_value())
-					return {};
-				MUST(result.path.push_back(name_seg.release_value()));
-			}
-
-			return result;
-		}
-
-		void debug_print() const
-		{
-			for (size_t i = 0; i < prefix.size(); i++)
-				AML_DEBUG_PUTC(prefix[i]);
-			if (!path.empty())
-				path.front().debug_print();
-			for (size_t i = 1; i < path.size(); i++)
-			{
-				AML_DEBUG_PUTC('.');
-				path[i].debug_print();
-			}
-		}
-	};
-
-}
-
-namespace BAN
-{
-
-	template<>
-	struct hash<Kernel::ACPI::AML::NameSeg>
-	{
-		constexpr hash_t operator()(Kernel::ACPI::AML::NameSeg name) const
-		{
-			return hash<uint32_t>()(name.u32);
-		}
-	};
-
-	template<typename F>
-	void Formatter::print_argument(F putc, const Kernel::ACPI::AML::NameSeg& name_seg, const ValueFormat&)
-	{
-		size_t len = 4;
-		while (len > 0 && name_seg.chars[len - 1] == '_')
-			len--;
-		for (size_t i = 0; i < len; i++)
-			putc(name_seg.chars[i]);
-	}
-
-	template<typename F>
-	void Formatter::print_argument(F putc, const Kernel::ACPI::AML::NameString& name_string, const ValueFormat&)
-	{
-		print_argument(putc, name_string.prefix, {});
-		if (!name_string.path.empty())
-			print_argument(putc, name_string.path.front(), {});
-		for (size_t i = 1; i < name_string.path.size(); i++)
-		{
-			putc('.');
-			print_argument(putc, name_string.path[i], {});
-		}
-	}
-
-}

kernel/include/kernel/ACPI/AML/Namespace.h

@@ -1,63 +1,74 @@
 #pragma once
 
+#include <BAN/Bitcast.h>
+#include <BAN/ByteSpan.h>
+#include <BAN/Function.h>
 #include <BAN/HashMap.h>
-#include <kernel/ACPI/AML/Scope.h>
-#include <kernel/ACPI/Headers.h>
-#include <kernel/Lock/Mutex.h>
+#include <BAN/HashSet.h>
+#include <BAN/Iteration.h>
+
+#include <kernel/ACPI/AML/Node.h>
 
 namespace Kernel::ACPI::AML
 {
 
-	struct Namespace : public AML::Scope
+	struct Namespace
 	{
-		static BAN::RefPtr<AML::Namespace> root_namespace();
+		BAN_NON_COPYABLE(Namespace);
+		BAN_NON_MOVABLE(Namespace);
+	public:
+		Namespace() = default;
+		~Namespace();
 
-		template<typename F>
-		static void for_each_child(const AML::NameString& scope, const F& callback)
+		static BAN::ErrorOr<void> prepare_root_namespace();
+		static Namespace& root_namespace();
+
+		BAN::ErrorOr<void> post_load_initialize();
+
+		BAN::ErrorOr<void> parse(BAN::ConstByteSpan);
+
+		BAN::ErrorOr<Node> evaluate(BAN::StringView path) { return evaluate(Scope {}, path); }
+		BAN::ErrorOr<Node> evaluate(const Scope& scope, BAN::StringView);
+
+		// returns empty scope if object already exited
+		BAN::ErrorOr<Scope> add_named_object(ParseContext& context, const NameString& name_string, Node&& node);
+		BAN::ErrorOr<Scope> add_alias(ParseContext& scope, const NameString& name_string, Reference* reference);
+
+		BAN::ErrorOr<void> remove_named_object(const Scope& absolute_path);
+
+		// node is nullptr if it is not found
+		struct FindResult
 		{
-			auto canonical_path = root_namespace()->resolve_path(scope, {}, FindMode::ForceAbsolute);
-			ASSERT(canonical_path.has_value());
-
-			for (auto& [path, child] : root_namespace()->m_objects)
-			{
-				if (path.size() < canonical_path->size() + 1)
-					continue;
-				if (canonical_path->size() != 1 && path[canonical_path->size()] != '.')
-					continue;
-				if (path.sv().substring(0, canonical_path->size()) != canonical_path->sv())
-					continue;
-				if (path.sv().substring(canonical_path->size() + 1).contains('.'))
-					continue;
-				callback(path, child);
-			}
-		}
-
-		Namespace(NameSeg name) : AML::Scope(Node::Type::Namespace, name) {}
-
-		static BAN::RefPtr<AML::Namespace> create_root_namespace();
-		bool parse(const SDTHeader& header);
-
-		void debug_print(int indent) const override;
-
-		enum class FindMode
-		{
-			Normal,
-			ForceAbsolute,
+			Scope path;
+			Reference* node { nullptr };
 		};
-		BAN::Optional<BAN::String> resolve_path(const AML::NameString& relative_base, const AML::NameString& relative_path, FindMode mode, bool check_existence = true) const;
+		BAN::ErrorOr<FindResult> find_named_object(const Scope& scope, const NameString& name_string, bool force_absolute = false);
 
-		// Find an object in the namespace. Returns nullptr if the object is not found.
-		BAN::RefPtr<NamedObject> find_object(const AML::NameString& relative_base, const AML::NameString& relative_path, FindMode mode);
+		BAN::ErrorOr<Scope> find_reference_scope(const Reference* reference);
 
-		// Add an object to the namespace. Returns false if the parent object could not be added.
-		bool add_named_object(ParseContext&, const AML::NameString& object_path, BAN::RefPtr<NamedObject> object);
+		BAN::ErrorOr<void> for_each_child(const Scope&, const BAN::Function<BAN::Iteration(BAN::StringView, Reference*)>&);
+		BAN::ErrorOr<void> for_each_child(const Scope&, const BAN::Function<BAN::Iteration(const Scope&, Reference*)>&);
 
-		// Remove an object from the namespace. Returns false if the object could not be removed.
-		bool remove_named_object(const AML::NameString& absolute_path);
+		BAN::ErrorOr<BAN::Vector<Scope>> find_device_with_eisa_id(BAN::StringView eisa_id);
+		BAN::ErrorOr<BAN::Vector<Scope>> find_device_with_eisa_id(BAN::Span<BAN::StringView> eisa_ids);
 
 	private:
-		BAN::HashMap<BAN::String, BAN::RefPtr<NamedObject>> m_objects;
-		mutable Mutex m_object_mutex;
+		BAN::ErrorOr<Scope> resolve_path(const Scope& scope, const NameString& name_string);
+
+		BAN::ErrorOr<void> initialize_scope(const Scope& scope);
+
+		BAN::ErrorOr<void> opregion_call_reg(const Scope& scope, const Node& opregion);
+
+		BAN::ErrorOr<uint64_t> evaluate_sta(const Scope& scope);
+		BAN::ErrorOr<void> evaluate_ini(const Scope& scope);
+
+		BAN::ErrorOr<void> initialize_op_regions();
+
+	private:
+		bool m_has_initialized_namespace { false };
+		BAN::HashMap<Scope, Reference*> m_named_objects;
+		BAN::HashMap<Scope, uint32_t> m_called_reg_bitmaps;
+		BAN::HashSet<Scope> m_aliases;
 	};
 
 }

kernel/include/kernel/ACPI/AML/Node.h

@@ -1,95 +1,449 @@
 #pragma once
 
+#include <BAN/Array.h>
 #include <BAN/ByteSpan.h>
+#include <BAN/LinkedList.h>
+#include <BAN/NoCopyMove.h>
 #include <BAN/Optional.h>
-#include <BAN/RefPtr.h>
+#include <BAN/StringView.h>
 #include <BAN/Vector.h>
-#include <kernel/ACPI/AML/Utils.h>
+
+#include <kernel/ACPI/AML/Scope.h>
+#include <kernel/ACPI/Headers.h>
+#include <kernel/Lock/Mutex.h>
+
+#define AML_DUMP_FUNCTION_CALLS 0
+#define AML_ENABLE_DEBUG 1
 
 namespace Kernel::ACPI::AML
 {
 
-	struct Node : public BAN::RefCounted<Node>
+	struct NameString
 	{
-		static uint64_t total_node_count;
+		BAN_NON_COPYABLE(NameString);
+	public:
+		NameString() = default;
+		NameString(NameString&& other)
+			: base(other.base)
+			, parts(BAN::move(other.parts))
+		{}
+		NameString& operator=(NameString&& other)
+		{
+			base = other.base;
+			parts = BAN::move(other.parts);
+			return *this;
+		}
+
+		static BAN::ErrorOr<NameString> from_string(BAN::StringView name);
+
+		BAN::ErrorOr<NameString> copy() const
+		{
+			NameString result;
+			result.base = this->base;
+
+			TRY(result.parts.resize(parts.size()));
+			for (size_t i = 0; i < parts.size(); i++)
+				result.parts[i] = parts[i];
+
+			return result;
+		}
+
+		static constexpr uint32_t base_root = -1;
+		uint32_t base { 0 };
+		BAN::Vector<uint32_t> parts;
+	};
+
+	template<typename T1, typename T2>
+	struct Pair
+	{
+		T1 elem1;
+		T2 elem2;
+	};
+
+	struct Node;
+	struct ParseContext;
+	struct Reference;
+
+	struct Mutex
+	{
+		Kernel::Mutex mutex;
+		uint8_t sync_level;
+		bool global_lock;
+		uint32_t ref_count;
+	};
+
+	struct Buffer
+	{
+		BAN::StringView as_sv() const
+		{
+			return BAN::StringView(reinterpret_cast<const char*>(bytes), size);
+		}
+
+		uint64_t size;
+		uint32_t ref_count;
+		uint8_t bytes[];
+	};
+
+	struct OpRegion
+	{
+		GAS::AddressSpaceID address_space;
+		uint64_t offset;
+		uint64_t length;
+		alignas(Scope) uint8_t scope_storage[sizeof(Scope)];
+		Scope& scope() { return *reinterpret_cast<Scope*>(scope_storage); }
+		const Scope& scope() const { return *reinterpret_cast<const Scope*>(scope_storage); }
+	};
+
+	struct FieldUnit
+	{
+		enum class Type {
+			Field,
+			IndexField,
+			BankField,
+		};
+		uint64_t offset;
+		uint64_t length;
+		uint8_t flags;
+		Type type;
+
+		union {
+			struct {
+				OpRegion opregion;
+			} field;
+			struct {
+				Reference* index;
+				Reference* data;
+			} index_field;
+			struct {
+				OpRegion opregion;
+				Reference* bank_selector;
+				uint64_t bank_value;
+			} bank_field;
+		} as;
+	};
+
+	struct Package
+	{
+		struct Element
+		{
+			struct Location {
+				NameString name;
+				Scope scope;
+			};
+
+			bool resolved { true };
+			union {
+				Node* node { nullptr };
+				Location* location;
+			} value;
+		};
+
+		uint64_t num_elements;
+		uint32_t ref_count;
+		Element elements[];
+	};
+
+	struct Node
+	{
+		BAN_NON_COPYABLE(Node);
+	public:
+		Node() = default;
+		~Node() { clear(); }
+
+		Node(Node&& other) { *this = BAN::move(other); }
+		Node& operator=(Node&&);
+
+		static BAN::ErrorOr<Node> create_string(BAN::StringView string)
+		{
+			const auto* u8_data = reinterpret_cast<const uint8_t*>(string.data());
+			auto result = TRY(create_buffer({ u8_data, string.size() }));
+			result.type = Node::Type::String;
+			return result;
+		}
+
+		static BAN::ErrorOr<Node> create_buffer(BAN::ConstByteSpan buffer)
+		{
+			Node node;
+			node.type = Node::Type::Buffer;
+			node.as.str_buf = static_cast<Buffer*>(kmalloc(sizeof(Buffer) + buffer.size()));
+			if (node.as.str_buf == nullptr)
+				return BAN::Error::from_errno(ENOMEM);
+			node.as.str_buf->ref_count = 1;
+			node.as.str_buf->size = buffer.size();
+			memcpy(node.as.str_buf->bytes, buffer.data(), buffer.size());
+			return node;
+		}
 
 		enum class Type
 		{
-			BankFieldElement,
-			Buffer,
-			BufferField,
-			Device,
-			FieldElement,
-			IndexFieldElement,
+			Uninitialized,
+			Debug,
 			Integer,
+			String,
+			Buffer,
+			Package,
+			BufferField,
+			OpRegion,
+			FieldUnit,
+			Event,
+			Device,
+			Processor,
+			PowerResource,
+			ThermalZone,
 			Method,
 			Mutex,
-			Name,
-			Namespace,
-			OpRegion,
-			Package,
-			PackageElement,
-			PowerResource,
-			Processor,
+			// FIXME: Index should not be its own type
+			//        parsing index should return references
+			Index,
 			Reference,
-			Register,
-			String,
-			ThermalZone,
-		};
-		const Type type;
+			PredefinedScope,
+			Count
+		} type { Type::Uninitialized };
 
-		Node(Type type) : type(type) { total_node_count++; }
-		virtual ~Node() { total_node_count--; }
+		inline bool is_scope() const
+		{
+			switch (type)
+			{
+				case Type::Device:
+				case Type::Processor:
+				case Type::PowerResource:
+				case Type::ThermalZone:
+				case Type::PredefinedScope:
+					return true;
+				default:
+					return false;
+			}
+			ASSERT_NOT_REACHED();
+		}
 
-		virtual bool is_scope() const { return false; }
+		union
+		{
+			struct {
+				uint64_t value;
+			} integer;
+			Package* package;
+			Buffer* str_buf;
+			struct {
+				Buffer* buffer;
+				uint64_t bit_offset;
+				uint64_t bit_count;
+			} buffer_field;
+			OpRegion opregion;
+			FieldUnit field_unit;
+			struct {
+				uint32_t signal_count;
+			} event;
+			struct {
+				uint8_t storage[sizeof(Kernel::Mutex)];
+				const uint8_t* start;
+				size_t length;
+				uint8_t arg_count;
+				BAN::ErrorOr<Node> (*override_func)(const BAN::Array<Reference*, 7>&);
+				bool serialized;
+				Mutex* mutex;
+			} method;
+			Mutex* mutex;
+			struct {
+				Node::Type type;
+				union {
+					Buffer* str_buf;
+					Package* package;
+				} as;
+				uint64_t index;
+			} index;
+			Reference* reference;
+		} as;
 
-		[[nodiscard]] BAN::Optional<uint64_t> as_integer();
-		[[nodiscard]] virtual BAN::RefPtr<AML::Node> evaluate() { AML_TODO("evaluate, type {}", static_cast<uint8_t>(type)); return nullptr; }
-		[[nodiscard]] virtual bool store(BAN::RefPtr<AML::Node> source) { AML_TODO("store, type {}", static_cast<uint8_t>(type)); return false; }
+		BAN::ErrorOr<Node> copy() const;
 
-		virtual void debug_print(int indent) const = 0;
+		void clear();
 	};
 
-	struct ParseContext;
-	struct ParseResult
+	struct Reference
 	{
-		static ParseResult Failure;
-		static ParseResult Success;
-
-		enum class Result
-		{
-			Success,
-			Failure,
-			Returned,
-		};
-
-		ParseResult(Result success)
-			: m_result(success)
-		{}
-		ParseResult(Result success, BAN::RefPtr<Node> node)
-			: m_result(success)
-			, m_node(BAN::move(node))
-		{}
-		ParseResult(BAN::RefPtr<Node> node)
-			: m_result(Result::Success)
-			, m_node(BAN::move(node))
-		{
-			ASSERT(m_node);
-		}
-
-		bool success() const { return m_result == Result::Success; }
-		bool returned() const { return m_result == Result::Returned; }
-
-		BAN::RefPtr<Node> node()
-		{
-			ASSERT(m_node);
-			return m_node;
-		}
-
-	private:
-		Result m_result = Result::Failure;
-		BAN::RefPtr<Node> m_node;
+		Node node {};
+		uint32_t ref_count { 1 };
 	};
-	ParseResult parse_object(ParseContext& context);
+
+	struct ParseContext
+	{
+		Scope scope;
+		BAN::ConstByteSpan aml_data;
+
+		uint32_t call_depth { 0 };
+		BAN::Array<Reference*, 8> locals;
+		BAN::Array<Reference*, 7> args;
+
+		BAN::LinkedList<Scope> created_nodes;
+
+		~ParseContext();
+		BAN::ErrorOr<void> allocate_locals();
+	};
+
+	enum class ExecutionFlow
+	{
+		Normal,
+		Break,
+		Continue,
+		Return,
+	};
+	using ExecutionFlowResult = Pair<ExecutionFlow, BAN::Optional<Node>>;
+
+	enum Conversion : uint8_t
+	{
+		ConvInteger = 1,
+		ConvBuffer  = 2,
+		ConvString  = 4,
+	};
+
+	BAN::ErrorOr<Node> parse_node(ParseContext& context, bool return_ref = false);
+	BAN::ErrorOr<ExecutionFlowResult> parse_node_or_execution_flow(ParseContext& context);
+
+	BAN::ErrorOr<NameString> parse_name_string(BAN::ConstByteSpan& aml_data);
+	BAN::ErrorOr<BAN::ConstByteSpan> parse_pkg(BAN::ConstByteSpan& aml_data);
+
+	BAN::ErrorOr<Node> convert_node(Node&& source, uint8_t conversion, uint64_t max_length);
+	BAN::ErrorOr<Node> convert_node(Node&& source, const Node& target);
+
+	BAN::ErrorOr<Node> evaluate_node(const Scope& node_path, const Node& node);
+
+	// If method has no return, it will return <integer 0>
+	BAN::ErrorOr<Node> method_call(const Scope& scope, const Node& method, BAN::Array<Reference*, 7>&& args, uint32_t call_depth = 0);
+	BAN::ErrorOr<Node> method_call(const Scope& scope, const Node& method,
+		Node&& arg0 = {}, Node&& arg1 = {}, Node&& arg2 = {}, Node&& arg3 = {}, Node&& arg4 = {}, Node&& arg5 = {}, Node&& arg6 = {});
+
+	BAN::ErrorOr<void> resolve_package_element(Package::Element& element, bool error_if_not_exists);
+
+}
+
+namespace BAN::Formatter
+{
+
+	template<typename F>
+	void print_argument(F putc, const Kernel::ACPI::AML::NameString& name_string, const ValueFormat&)
+	{
+		if (name_string.base == Kernel::ACPI::AML::NameString::base_root)
+			putc('\\');
+		else for (uint32_t i = 0; i < name_string.base; i++)
+			putc('^');
+		for (size_t i = 0; i < name_string.parts.size(); i++) {
+			if (i != 0)
+				putc('.');
+			const char* name_seg = reinterpret_cast<const char*>(&name_string.parts[i]);
+			putc(name_seg[0]); putc(name_seg[1]); putc(name_seg[2]); putc(name_seg[3]);
+		}
+	}
+
+	template<typename F>
+	void print_argument(F putc, const Kernel::ACPI::AML::Buffer& buffer, const ValueFormat&)
+	{
+		static constexpr size_t max_elements { 16 };
+
+		print(putc, "<buffer '");
+		if (buffer.size)
+			print(putc, "{2H}", buffer.bytes[0]);
+		for (size_t i = 1; i < buffer.size && i < max_elements; i++)
+			print(putc, " {2H}", buffer.bytes[i]);
+		if (buffer.size > max_elements)
+			print(putc, "...");
+		print(putc, "'>");
+	}
+
+	template<typename F>
+	void print_argument(F putc, const Kernel::ACPI::AML::Package& package, const ValueFormat&)
+	{
+		print(putc, "<package '{} elements'>", package.num_elements);
+	}
+
+	template<typename F>
+	void print_argument(F putc, const Kernel::ACPI::AML::Node& node, const ValueFormat&)
+	{
+		switch (node.type)
+		{
+			case Kernel::ACPI::AML::Node::Type::Uninitialized:
+				print(putc, "<uninitialized>");
+				break;
+			case Kernel::ACPI::AML::Node::Type::Debug:
+				print(putc, "<debug>");
+				break;
+			case Kernel::ACPI::AML::Node::Type::Integer:
+				print(putc, "<integer 0x{H}>", node.as.integer.value);
+				break;
+			case Kernel::ACPI::AML::Node::Type::String:
+				print(putc, "<string '{}'>", node.as.str_buf->as_sv());
+				break;
+			case Kernel::ACPI::AML::Node::Type::Package:
+				print(putc, "{}", *node.as.package);
+				break;
+			case Kernel::ACPI::AML::Node::Type::Buffer:
+				print(putc, "{}", *node.as.str_buf);
+				break;
+			case Kernel::ACPI::AML::Node::Type::BufferField:
+				print(putc, "<buffer field '{} bytes, offset 0x{H}, bit count {}'>",
+					node.as.buffer_field.buffer->size,
+					node.as.buffer_field.bit_offset,
+					node.as.buffer_field.bit_count
+				);
+				break;
+			case Kernel::ACPI::AML::Node::Type::OpRegion:
+				print(putc, "<opregion 'type {2H}, offset 0x{H}, length 0x{H}'>",
+					static_cast<uint8_t>(node.as.opregion.address_space),
+					node.as.opregion.offset,
+					node.as.opregion.length
+				);
+				break;
+			case Kernel::ACPI::AML::Node::Type::FieldUnit:
+				print(putc, "<field unit ({}), 'offset 0x{H}, length 0x{H}'>",
+					static_cast<uint8_t>(node.as.field_unit.type),
+					node.as.field_unit.offset,
+					node.as.field_unit.length
+				);
+				break;
+			case Kernel::ACPI::AML::Node::Type::Event:
+				print(putc, "<event '{} signals'>", node.as.event.signal_count);
+				break;
+			case Kernel::ACPI::AML::Node::Type::Device:
+				print(putc, "<device>");
+				break;
+			case Kernel::ACPI::AML::Node::Type::Processor:
+				print(putc, "<processor>");
+				break;
+			case Kernel::ACPI::AML::Node::Type::PowerResource:
+				print(putc, "<power resouce>");
+				break;
+			case Kernel::ACPI::AML::Node::Type::ThermalZone:
+				print(putc, "<thermal zone>");
+				break;
+			case Kernel::ACPI::AML::Node::Type::Method:
+				print(putc, "<method '{} bytes'>", node.as.method.length);
+				break;
+			case Kernel::ACPI::AML::Node::Type::Mutex:
+				print(putc, "<mutex>");
+				break;
+			case Kernel::ACPI::AML::Node::Type::Index:
+				switch (node.as.index.type)
+				{
+					case Kernel::ACPI::AML::Node::Type::String:
+					case Kernel::ACPI::AML::Node::Type::Buffer:
+						print(putc, "<index {}, {}>", *node.as.index.as.str_buf, node.as.index.index);
+						break;
+					case Kernel::ACPI::AML::Node::Type::Package:
+						print(putc, "<index {}, {}>", *node.as.index.as.package, node.as.index.index);
+						break;
+					default:
+						print(putc, "<index {}??, {}>", (uint32_t)node.as.index.type, node.as.index.index);
+						break;
+				}
+				break;
+			case Kernel::ACPI::AML::Node::Type::Reference:
+				print(putc, "<reference {}, {} refs>", node.as.reference->node, node.as.reference->ref_count);
+				break;
+			case Kernel::ACPI::AML::Node::Type::PredefinedScope:
+				print(putc, "<scope>");
+				break;
+			case Kernel::ACPI::AML::Node::Type::Count:
+				ASSERT_NOT_REACHED();
+		}
+	}
 
 }

kernel/include/kernel/ACPI/AML/Notify.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/AML/Device.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/ACPI/AML/Processor.h>
-#include <kernel/ACPI/AML/ThermalZone.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct Notify
-	{
-		static ParseResult parse(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 1);
-			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::NotifyOp);
-			context.aml_data = context.aml_data.slice(1);
-
-			auto object_result = AML::parse_object(context);
-			if (!object_result.success())
-				return ParseResult::Failure;
-			auto object = object_result.node();
-			if (!object)
-			{
-				AML_ERROR("Notify object is null");
-				return ParseResult::Failure;
-			}
-
-			auto value_result = AML::parse_object(context);
-			if (!value_result.success())
-				return ParseResult::Failure;
-			auto value = value_result.node() ? value_result.node()->as_integer() : BAN::Optional<uint64_t>();
-			if (!value.has_value())
-			{
-				AML_ERROR("Notify value is not an integer");
-				return ParseResult::Failure;
-			}
-
-			BAN::StringView object_type_sv;
-			BAN::StringView object_name_sv;
-			switch (object->type)
-			{
-				case AML::Node::Type::Device:
-					object_type_sv = "Device"sv;
-					object_name_sv = static_cast<AML::Device*>(object.ptr())->name.sv();
-					break;
-				case AML::Node::Type::Processor:
-					object_type_sv = "Processor"sv;
-					object_name_sv = static_cast<AML::Processor*>(object.ptr())->name.sv();
-					break;
-				case AML::Node::Type::ThermalZone:
-					object_type_sv = "ThermalZone"sv;
-					object_name_sv = static_cast<AML::ThermalZone*>(object.ptr())->name.sv();
-					break;
-				default:
-					object_type_sv = "Unknown"sv;
-					object_name_sv = "????"sv;
-					break;
-			}
-
-			AML_TODO("Notify: {} {}: {2H}", object_type_sv, object_name_sv, value.value());
-			return ParseResult::Success;
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/OpRegion.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <kernel/ACPI/AML/Node.h>
+
+namespace Kernel::ACPI::AML
+{
+
+	BAN::ErrorOr<void> parse_opregion_op(ParseContext& context);
+	BAN::ErrorOr<void> parse_field_op(ParseContext& context);
+	BAN::ErrorOr<void> parse_index_field_op(ParseContext& context);
+	BAN::ErrorOr<void> parse_bank_field_op(ParseContext& context);
+
+	BAN::ErrorOr<Node> convert_from_field_unit(const Node& node, uint8_t conversion, uint64_t max_length);
+	BAN::ErrorOr<void> store_to_field_unit(const Node& source, const Node& target);
+
+}

kernel/include/kernel/ACPI/AML/Package.h

@@ -1,134 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/AML/Bytes.h>
-#include <kernel/ACPI/AML/Node.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/ACPI/AML/Pkg.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct PackageElement;
-
-	struct Package : public AML::Node
-	{
-		BAN::Vector<BAN::RefPtr<PackageElement>> elements;
-		AML::NameString scope;
-
-		Package(AML::NameString scope)
-			: Node(Node::Type::Package)
-			, elements(BAN::move(elements))
-			, scope(scope)
-		{}
-
-		BAN::RefPtr<AML::Node> evaluate() override
-		{
-			return this;
-		}
-
-		static ParseResult parse(AML::ParseContext& context);
-		virtual void debug_print(int indent) const override;
-	};
-
-	struct PackageElement : public AML::Node
-	{
-		BAN::RefPtr<AML::Package> parent;
-		BAN::RefPtr<AML::Node> element;
-		AML::NameString unresolved_name;
-		bool resolved = false;
-		bool initialized = false;
-
-		PackageElement(BAN::RefPtr<AML::Package> parent, BAN::RefPtr<AML::Node> element)
-			: Node(Node::Type::PackageElement)
-			, parent(parent)
-			, element(element)
-		{
-			ASSERT(element);
-			resolved = true;
-			initialized = true;
-		}
-
-		PackageElement(BAN::RefPtr<AML::Package> parent, AML::NameString unresolved_name)
-			: Node(Node::Type::PackageElement)
-			, parent(parent)
-			, unresolved_name(unresolved_name)
-		{
-			resolved = false;
-			initialized = true;
-		}
-
-		PackageElement(BAN::RefPtr<AML::Package> parent)
-			: Node(Node::Type::PackageElement)
-			, parent(parent)
-			, unresolved_name(unresolved_name)
-		{
-			resolved = false;
-			initialized = false;
-		}
-
-		BAN::RefPtr<AML::Node> evaluate() override
-		{
-			if (!initialized)
-			{
-				AML_ERROR("Trying to evaluate uninitialized PackageElement");
-				return {};
-			}
-			if (!resolved)
-			{
-				auto object = Namespace::root_namespace()->find_object(parent->scope, unresolved_name, Namespace::FindMode::Normal);
-				if (!object)
-				{
-					AML_ERROR("Failed to resolve reference {} in package {}", unresolved_name, parent->scope);
-					return {};
-				}
-				element = object;
-				resolved = true;
-			}
-			return element->evaluate();
-		}
-
-		static ParseResult parse(AML::ParseContext& context, BAN::RefPtr<AML::Package> package)
-		{
-			BAN::RefPtr<AML::PackageElement> element;
-			if (context.aml_data[0] != 0x00 && AML::NameString::can_parse(context.aml_data))
-			{
-				auto name = AML::NameString::parse(context.aml_data);
-				if (!name.has_value())
-					return ParseResult::Failure;
-				element = MUST(BAN::RefPtr<PackageElement>::create(package, name.value()));
-			}
-			else
-			{
-				auto element_result = AML::parse_object(context);
-				if (!element_result.success())
-					return ParseResult::Failure;
-				element = MUST(BAN::RefPtr<PackageElement>::create(package, element_result.node()));
-			}
-			return ParseResult(element);
-		}
-
-		virtual void debug_print(int indent) const override
-		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINTLN("PackageElement {");
-			if (!initialized)
-			{
-				AML_DEBUG_PRINT_INDENT(indent + 1);
-				AML_DEBUG_PRINT("Uninitialized");
-			}
-			else if (!resolved)
-			{
-				AML_DEBUG_PRINT_INDENT(indent + 1);
-				AML_DEBUG_PRINT("Unresolved {}", unresolved_name);
-			}
-			else
-			{
-				element->debug_print(indent + 1);
-			}
-			AML_DEBUG_PRINTLN("");
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("}");
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/ParseContext.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#include <BAN/Array.h>
-#include <BAN/ByteSpan.h>
-#include <BAN/LinkedList.h>
-#include <kernel/ACPI/AML/NamedObject.h>
-#include <kernel/ACPI/AML/Namespace.h>
-#include <kernel/ACPI/AML/Register.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct ParseContext
-	{
-		BAN::ConstByteSpan	aml_data;
-		AML::NameString		scope;
-
-		// Used for cleaning up on method exit
-		// NOTE: This uses linked list instead of vector because
-		//       we don't really need large contiguous memory
-		BAN::LinkedList<AML::NameString> created_objects;
-
-		uint8_t sync_level() const {  return !sync_stack.empty() ? sync_stack.back() : 0; }
-		BAN::Vector<uint8_t> sync_stack;
-
-		BAN::Array<BAN::RefPtr<Register>, 7> method_args;
-		BAN::Array<BAN::RefPtr<Register>, 8> method_locals;
-	};
-
-}

kernel/include/kernel/ACPI/AML/Pkg.h

@@ -1,51 +0,0 @@
-#pragma once
-
-#include <BAN/ByteSpan.h>
-#include <BAN/Optional.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	static BAN::Optional<uint32_t> parse_pkg_length(BAN::ConstByteSpan aml_data)
-	{
-		if (aml_data.size() < 1)
-			return {};
-
-		uint8_t lead_byte = aml_data[0];
-		if ((lead_byte & 0xC0) && (lead_byte & 0x30))
-			return {};
-
-		uint32_t pkg_length = lead_byte & 0x3F;
-		uint8_t byte_count = (lead_byte >> 6) + 1;
-
-		if (aml_data.size() < byte_count)
-			return {};
-
-		for (uint8_t i = 1; i < byte_count; i++)
-			pkg_length |= aml_data[i] << (i * 8 - 4);
-
-		return pkg_length;
-	}
-
-	static void trim_pkg_length(BAN::ConstByteSpan& aml_data)
-	{
-		ASSERT(aml_data.size() >= 1);
-		uint8_t byte_count = (aml_data[0] >> 6) + 1;
-		aml_data = aml_data.slice(byte_count);
-	}
-
-	static BAN::Optional<BAN::ConstByteSpan> parse_pkg(BAN::ConstByteSpan& aml_data)
-	{
-		auto pkg_length = parse_pkg_length(aml_data);
-		if (!pkg_length.has_value())
-			return {};
-
-		auto result = aml_data.slice(0, pkg_length.value());
-		trim_pkg_length(result);
-
-		aml_data = aml_data.slice(pkg_length.value());
-
-		return result;
-	}
-
-}

kernel/include/kernel/ACPI/AML/PowerResource.h

@@ -1,68 +0,0 @@
-#pragma once
-
-#include <BAN/Endianness.h>
-#include <kernel/ACPI/AML/Bytes.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/ACPI/AML/Pkg.h>
-#include <kernel/ACPI/AML/Scope.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct PowerResource : public AML::Scope
-	{
-		uint8_t system_level;
-		uint16_t resource_order;
-
-		PowerResource(NameSeg name, uint8_t system_level, uint16_t resource_order)
-			: Scope(Node::Type::PowerResource, name)
-			, system_level(system_level)
-			, resource_order(resource_order)
-		{}
-
-		static ParseResult parse(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 2);
-			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
-			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::PowerResOp);
-			context.aml_data = context.aml_data.slice(2);
-
-			auto opt_power_res_pkg = AML::parse_pkg(context.aml_data);
-			if (!opt_power_res_pkg.has_value())
-				return ParseResult::Failure;
-			auto power_res_pkg = opt_power_res_pkg.value();
-
-			auto name = NameString::parse(power_res_pkg);
-			if (!name.has_value())
-				return ParseResult::Failure;
-
-			if (power_res_pkg.size() < 1)
-				return ParseResult::Failure;
-			uint8_t system_level = power_res_pkg[0];
-			power_res_pkg = power_res_pkg.slice(1);
-
-			if (power_res_pkg.size() < 2)
-				return ParseResult::Failure;
-			uint16_t resource_order = BAN::little_endian_to_host<uint16_t>(*reinterpret_cast<const uint16_t*>(power_res_pkg.data()));
-			power_res_pkg = power_res_pkg.slice(2);
-
-			auto power_res = MUST(BAN::RefPtr<PowerResource>::create(name->path.back(), system_level, resource_order));
-			if (!Namespace::root_namespace()->add_named_object(context, name.value(), power_res))
-				return ParseResult::Failure;
-
-#if AML_DEBUG_LEVEL >= 2
-			power_res->debug_print(0);
-			AML_DEBUG_PRINTLN("");
-#endif
-
-			return power_res->enter_context_and_parse_term_list(context, name.value(), power_res_pkg);
-		}
-
-		virtual void debug_print(int indent) const override
-		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("PowerResource {} (SystemLevel {}, ResourceOrder {})", name, system_level, resource_order);
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/Processor.h

@@ -1,84 +0,0 @@
-#pragma once
-
-#include <BAN/Endianness.h>
-#include <kernel/ACPI/AML/Bytes.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-#include <kernel/ACPI/AML/Pkg.h>
-#include <kernel/ACPI/AML/Scope.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct Processor : public AML::Scope
-	{
-		uint8_t id;
-		uint32_t pblk_addr;
-		uint8_t pblk_len;
-
-		Processor(NameSeg name, uint8_t id, uint32_t pblk_addr, uint8_t pblk_len)
-			: Scope(Node::Type::Processor, name)
-			, id(id)
-			, pblk_addr(pblk_addr)
-			, pblk_len(pblk_len)
-		{}
-
-		static ParseResult parse(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 2);
-			ASSERT(static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::ExtOpPrefix);
-			ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::ProcessorOp);
-			context.aml_data = context.aml_data.slice(2);
-
-			auto opt_processor_pkg = AML::parse_pkg(context.aml_data);
-			if (!opt_processor_pkg.has_value())
-				return ParseResult::Failure;
-			auto processor_pkg = opt_processor_pkg.value();
-
-			auto name = NameString::parse(processor_pkg);
-			if (!name.has_value())
-				return ParseResult::Failure;
-
-			if (processor_pkg.size() < 1)
-				return ParseResult::Failure;
-			uint8_t id = processor_pkg[0];
-			processor_pkg = processor_pkg.slice(1);
-
-			if (processor_pkg.size() < 4)
-				return ParseResult::Failure;
-			uint32_t pblk_addr = BAN::little_endian_to_host<uint32_t>(*reinterpret_cast<const uint32_t*>(processor_pkg.data()));
-			processor_pkg = processor_pkg.slice(4);
-
-			if (processor_pkg.size() < 1)
-				return ParseResult::Failure;
-			uint8_t pblk_len = processor_pkg[0];
-			processor_pkg = processor_pkg.slice(1);
-
-			auto processor = MUST(BAN::RefPtr<Processor>::create(name->path.back(), id, pblk_addr, pblk_len));
-			if (!Namespace::root_namespace()->add_named_object(context, name.value(), processor))
-				return ParseResult::Failure;
-
-#if AML_DEBUG_LEVEL >= 2
-			processor->debug_print(0);
-			AML_DEBUG_PRINTLN("");
-#endif
-
-			return processor->enter_context_and_parse_term_list(context, name.value(), processor_pkg);
-		}
-
-		virtual void debug_print(int indent) const override
-		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINTLN("Processor {} (ID: {}, PBlkAddr: 0x{H}, PBlkLen: {}) {", name, id, pblk_addr, pblk_len);
-			Namespace::root_namespace()->for_each_child(scope,
-				[&](const auto&, const auto& child)
-				{
-					child->debug_print(indent + 1);
-					AML_DEBUG_PRINTLN("");
-				}
-			);
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("}");
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/Reference.h

@@ -1,155 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/AML/Bytes.h>
-#include <kernel/ACPI/AML/Integer.h>
-#include <kernel/ACPI/AML/Node.h>
-#include <kernel/ACPI/AML/Names.h>
-#include <kernel/ACPI/AML/String.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct Reference : public AML::Node
-	{
-		BAN::RefPtr<AML::Node> node;
-
-		Reference(BAN::RefPtr<AML::Node> node)
-			: Node(AML::Node::Type::Reference)
-			, node(node)
-		{
-			ASSERT(node);
-		}
-
-		BAN::RefPtr<AML::Node> evaluate() override
-		{
-			return this;
-		}
-
-		static ParseResult parse(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 1);
-
-			bool conditional = false;
-			switch (static_cast<AML::Byte>(context.aml_data[0]))
-			{
-				case AML::Byte::DerefOfOp:
-					return parse_dereference(context);
-				case AML::Byte::RefOfOp:
-					context.aml_data = context.aml_data.slice(1);
-					conditional = false;
-					break;
-				case AML::Byte::ExtOpPrefix:
-					ASSERT(static_cast<AML::ExtOp>(context.aml_data[1]) == AML::ExtOp::CondRefOfOp);
-					context.aml_data = context.aml_data.slice(2);
-					conditional = true;
-					break;
-				default:
-					ASSERT_NOT_REACHED();
-			}
-
-			BAN::RefPtr<AML::Node> object;
-			if (NameString::can_parse(context.aml_data))
-			{
-				auto name = NameString::parse(context.aml_data);
-				if (!name.has_value())
-					return ParseResult::Failure;
-				object = Namespace::root_namespace()->find_object(context.scope, name.value(), Namespace::FindMode::Normal);
-			}
-			else
-			{
-				auto parse_result = AML::parse_object(context);
-				if (!parse_result.success())
-					return ParseResult::Failure;
-				object = parse_result.node();
-			}
-
-			if (!conditional)
-			{
-				if (!object)
-				{
-					AML_ERROR("RefOf failed to resolve reference");
-					return ParseResult::Failure;
-				}
-				auto reference = MUST(BAN::RefPtr<Reference>::create(object));
-#if AML_DEBUG_LEVEL >= 2
-				reference->debug_print(0);
-				AML_DEBUG_PRINTLN("");
-#endif
-				return ParseResult(reference);
-			}
-
-			if (context.aml_data.size() >= 1 && context.aml_data[0] != 0x00)
-			{
-				auto target_result = AML::parse_object(context);
-				if (!target_result.success())
-					return ParseResult::Failure;
-				auto target_node = target_result.node();
-				if (!target_node)
-				{
-					AML_ERROR("CondRefOf failed to resolve target");
-					return ParseResult::Failure;
-				}
-				target_node->store(MUST(BAN::RefPtr<Reference>::create(object)));
-			}
-
-#if AML_DEBUG_LEVEL >= 2
-			AML_DEBUG_PRINT("CondRefOf ");
-			if (object)
-				object->debug_print(0);
-			else
-				AML_DEBUG_PRINT("null");
-			AML_DEBUG_PRINTLN("");
-#endif
-
-			auto return_value = object ? Integer::Constants::Ones : Integer::Constants::Zero;
-			return AML::ParseResult(return_value);
-		}
-
-		static ParseResult parse_dereference(ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() >= 1);
-			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::DerefOfOp);
-			context.aml_data = context.aml_data.slice(1);
-
-			if (context.aml_data.size() >= 1 && static_cast<AML::Byte>(context.aml_data[0]) == AML::Byte::StringPrefix)
-			{
-				auto string_result = AML::String::parse(context);
-				if (!string_result.success())
-					return ParseResult::Failure;
-				ASSERT(string_result.node());
-				auto string = static_cast<AML::String*>(string_result.node().ptr());
-				AML_TODO("DerefOf String ({})", string->string);
-				return ParseResult::Failure;
-			}
-			else
-			{
-				auto parse_result = AML::parse_object(context);
-				if (!parse_result.success())
-					return ParseResult::Failure;
-				auto object = parse_result.node();
-				if (!object || object->type != AML::Node::Type::Reference)
-				{
-					AML_TODO("DerefOf source is not a Reference, but a {}", object ? static_cast<uint8_t>(object->type) : 999);
-					return ParseResult::Failure;
-				}
-#if AML_DEBUG_LEVEL >= 2
-				AML_DEBUG_PRINT("DerefOf ");
-				object->debug_print(0);
-				AML_DEBUG_PRINTLN("");
-#endif
-				return ParseResult(static_cast<Reference*>(object.ptr())->node);
-			}
-		}
-
-		virtual void debug_print(int indent) const override
-		{
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINTLN("Reference {");
-			node->debug_print(indent + 1);
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("}");
-		}
-	};
-
-}

kernel/include/kernel/ACPI/AML/Region.h

@@ -1,106 +0,0 @@
-#pragma once
-
-#include <kernel/ACPI/AML/NamedObject.h>
-#include <kernel/ACPI/AML/Namespace.h>
-#include <kernel/ACPI/AML/ParseContext.h>
-
-namespace Kernel::ACPI::AML
-{
-
-	struct OpRegion : public NamedObject
-	{
-		using RegionSpace = GAS::AddressSpaceID;
-		RegionSpace region_space;
-		uint64_t region_offset;
-		uint64_t region_length;
-
-		Kernel::Mutex mutex;
-
-		OpRegion(NameSeg name, RegionSpace region_space, uint64_t region_offset, uint64_t region_length)
-			: NamedObject(Node::Type::OpRegion, name)
-			, region_space(region_space)
-			, region_offset(region_offset)
-			, region_length(region_length)
-		{}
-
-		static ParseResult parse(AML::ParseContext& context)
-		{
-			ASSERT(context.aml_data.size() > 2);
-			ASSERT(static_cast<Byte>(context.aml_data[0]) == Byte::ExtOpPrefix);
-			ASSERT(static_cast<ExtOp>(context.aml_data[1]) == ExtOp::OpRegionOp);
-			context.aml_data = context.aml_data.slice(2);
-
-			auto name = NameString::parse(context.aml_data);
-			if (!name.has_value())
-				return ParseResult::Failure;
-
-			if (context.aml_data.size() < 1)
-				return ParseResult::Failure;
-			auto region_space = static_cast<RegionSpace>(context.aml_data[0]);
-			context.aml_data = context.aml_data.slice(1);
-
-			auto offset_result = AML::parse_object(context);
-			if (!offset_result.success())
-				return ParseResult::Failure;
-			auto offset = offset_result.node()->as_integer();
-			if (!offset.has_value())
-			{
-				AML_ERROR("OpRegion offset must be an integer");
-				return ParseResult::Failure;
-			}
-
-			auto length_result = AML::parse_object(context);
-			if (!length_result.success())
-				return ParseResult::Failure;
-			auto length = length_result.node()->as_integer();
-			if (!length.has_value())
-			{
-				AML_ERROR("OpRegion length must be an integer");
-				return ParseResult::Failure;
-			}
-
-			auto op_region = MUST(BAN::RefPtr<OpRegion>::create(
-				name->path.back(),
-				region_space,
-				offset.value(),
-				length.value()
-			));
-
-			if (!Namespace::root_namespace()->add_named_object(context, name.value(), op_region))
-				return ParseResult::Failure;
-
-#if AML_DEBUG_LEVEL >= 2
-			op_region->debug_print(0);
-			AML_DEBUG_PRINTLN("");
-#endif
-
-			return ParseResult::Success;
-		}
-
-		virtual void debug_print(int indent) const override
-		{
-			BAN::StringView region_space_name;
-			switch (region_space)
-			{
-				case RegionSpace::SystemMemory:					region_space_name = "SystemMemory"sv; break;
-				case RegionSpace::SystemIO:						region_space_name = "SystemIO"sv; break;
-				case RegionSpace::PCIConfig:					region_space_name = "PCIConfig"sv; break;
-				case RegionSpace::EmbeddedController:			region_space_name = "EmbeddedController"sv; break;
-				case RegionSpace::SMBus:						region_space_name = "SMBus"sv; break;
-				case RegionSpace::SystemCMOS:					region_space_name = "SystemCMOS"sv; break;
-				case RegionSpace::PCIBarTarget:					region_space_name = "PCIBarTarget"sv; break;
-				case RegionSpace::IPMI:							region_space_name = "IPMI"sv; break;
-				case RegionSpace::GeneralPurposeIO:				region_space_name = "GeneralPurposeIO"sv; break;
-				case RegionSpace::GenericSerialBus:				region_space_name = "GenericSerialBus"sv; break;
-				case RegionSpace::PlatformCommunicationChannel:	region_space_name = "PlatformCommunicationChannel"sv; break;
-				default: region_space_name = "Unknown"sv; break;
-			}
-			AML_DEBUG_PRINT_INDENT(indent);
-			AML_DEBUG_PRINT("OperationRegion(");
-			name.debug_print();
-			AML_DEBUG_PRINT(", {}, 0x{H}, 0x{H})", region_space_name, region_offset, region_length);
-		}
-
-	};
-
-}