build: Build mlibc + add distclean target

Signed-off-by: Ian Moffett <ian@osmora.org>

1 files changed, 0 insertions, 217 deletions

diff --git a/lib/mlibc/options/internal/generic/essential.cpp b/lib/mlibc/options/internal/generic/essential.cpp
deleted file mode 100644
index d00df1e..0000000
--- a/lib/mlibc/options/internal/generic/essential.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-#include <string.h>
-#include <stdint.h>
-
-namespace {
-	// Needed since we cannot declare a templated enum.
-	template<typename T>
-	struct word_helper {
-		using underlying [[gnu::aligned(1)]] = T;
-		enum class [[gnu::may_alias]] word_enum : underlying { };
-	};
-
-	template<typename T>
-	using word = typename word_helper<T>::word_enum;
-
-	template<typename T>
-	[[gnu::always_inline]]
-	inline word<T> alias_load(const unsigned char *&p) {
-		word<T> value = *reinterpret_cast<const word<T> *>(p);
-		p += sizeof(T);
-		return value;
-	}
-
-	template<typename T>
-	[[gnu::always_inline]]
-	inline void alias_store(unsigned char *&p, word<T> value) {
-		*reinterpret_cast<word<T> *>(p) = value;
-		p += sizeof(T);
-	}
-
-#ifdef __LP64__
-	void *forward_copy(void *__restrict dest, const void *__restrict src, size_t n) {
-		auto curDest = reinterpret_cast<unsigned char *>(dest);
-		auto curSrc = reinterpret_cast<const unsigned char *>(src);
-
-		while(n >= 8 * 8) {
-			auto w1 = alias_load<uint64_t>(curSrc);
-			auto w2 = alias_load<uint64_t>(curSrc);
-			auto w3 = alias_load<uint64_t>(curSrc);
-			auto w4 = alias_load<uint64_t>(curSrc);
-			auto w5 = alias_load<uint64_t>(curSrc);
-			auto w6 = alias_load<uint64_t>(curSrc);
-			auto w7 = alias_load<uint64_t>(curSrc);
-			auto w8 = alias_load<uint64_t>(curSrc);
-			alias_store<uint64_t>(curDest, w1);
-			alias_store<uint64_t>(curDest, w2);
-			alias_store<uint64_t>(curDest, w3);
-			alias_store<uint64_t>(curDest, w4);
-			alias_store<uint64_t>(curDest, w5);
-			alias_store<uint64_t>(curDest, w6);
-			alias_store<uint64_t>(curDest, w7);
-			alias_store<uint64_t>(curDest, w8);
-			n -= 8 * 8;
-		}
-		if(n >= 4 * 8) {
-			auto w1 = alias_load<uint64_t>(curSrc);
-			auto w2 = alias_load<uint64_t>(curSrc);
-			auto w3 = alias_load<uint64_t>(curSrc);
-			auto w4 = alias_load<uint64_t>(curSrc);
-			alias_store<uint64_t>(curDest, w1);
-			alias_store<uint64_t>(curDest, w2);
-			alias_store<uint64_t>(curDest, w3);
-			alias_store<uint64_t>(curDest, w4);
-			n -= 4 * 8;
-		}
-		if(n >= 2 * 8) {
-			auto w1 = alias_load<uint64_t>(curSrc);
-			auto w2 = alias_load<uint64_t>(curSrc);
-			alias_store<uint64_t>(curDest, w1);
-			alias_store<uint64_t>(curDest, w2);
-			n -= 2 * 8;
-		}
-		if(n >= 8) {
-			auto w = alias_load<uint64_t>(curSrc);
-			alias_store<uint64_t>(curDest, w);
-			n -= 8;
-		}
-		if(n >= 4) {
-			auto w = alias_load<uint32_t>(curSrc);
-			alias_store<uint32_t>(curDest, w);
-			n -= 4;
-		}
-		if(n >= 2) {
-			auto w = alias_load<uint16_t>(curSrc);
-			alias_store<uint16_t>(curDest, w);
-			n -= 2;
-		}
-		if(n)
-			*curDest = *curSrc;
-		return dest;
-	}
-#else // !__LP64__
-	void *forward_copy(void *dest, const void *src, size_t n) {
-		for(size_t i = 0; i < n; i++)
-			((char *)dest)[i] = ((const char *)src)[i];
-		return dest;
-	}
-#endif // __LP64__ / !__LP64__
-}
-
-// --------------------------------------------------------------------------------------
-// memcpy() implementation.
-// --------------------------------------------------------------------------------------
-
-
-void *memcpy(void *__restrict dest, const void *__restrict src, size_t n) {
-	return forward_copy(dest, src, n);
-}
-
-
-// --------------------------------------------------------------------------------------
-// memset() implementation.
-// --------------------------------------------------------------------------------------
-
-#ifdef __LP64__
-
-void *memset(void *dest, int val, size_t n) {
-	auto curDest = reinterpret_cast<unsigned char *>(dest);
-	unsigned char byte = val;
-
-	// Get rid of misalignment.
-	while(n && (reinterpret_cast<uintptr_t>(curDest) & 7)) {
-		*curDest++ = byte;
-		--n;
-	}
-
-	auto pattern64 = static_cast<word<uint64_t>>(
-			static_cast<uint64_t>(byte)
-			| (static_cast<uint64_t>(byte) << 8)
-			| (static_cast<uint64_t>(byte) << 16)
-			| (static_cast<uint64_t>(byte) << 24)
-			| (static_cast<uint64_t>(byte) << 32)
-			| (static_cast<uint64_t>(byte) << 40)
-			| (static_cast<uint64_t>(byte) << 48)
-			| (static_cast<uint64_t>(byte) << 56));
-
-	auto pattern32 = static_cast<word<uint32_t>>(
-			static_cast<uint32_t>(byte)
-			| (static_cast<uint32_t>(byte) << 8)
-			| (static_cast<uint32_t>(byte) << 16)
-			| (static_cast<uint32_t>(byte) << 24));
-
-	auto pattern16 = static_cast<word<uint16_t>>(
-			static_cast<uint16_t>(byte)
-			| (static_cast<uint16_t>(byte) << 8));
-
-	while(n >= 8 * 8) {
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		n -= 8 * 8;
-	}
-	if(n >= 4 * 8) {
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		n -= 4 * 8;
-	}
-	if(n >= 2 * 8) {
-		alias_store<uint64_t>(curDest, pattern64);
-		alias_store<uint64_t>(curDest, pattern64);
-		n -= 2 * 8;
-	}
-	if(n >= 8) {
-		alias_store<uint64_t>(curDest, pattern64);
-		n -= 8;
-	}
-	if(n >= 4) {
-		alias_store<uint32_t>(curDest, pattern32);
-		n -= 4;
-	}
-	if(n >= 2) {
-		alias_store<uint16_t>(curDest, pattern16);
-		n -= 2;
-	}
-	if(n)
-		*curDest = byte;
-	return dest;
-}
-
-#else // !__LP64__
-
-void *memset(void *dest, int byte, size_t count) {
-	for(size_t i = 0; i < count; i++)
-		((char *)dest)[i] = (char)byte;
-	return dest;
-}
-
-#endif // __LP64__ / !__LP64__
-
-// --------------------------------------------------------------------------------------
-// "Non-optimized" functions.
-// --------------------------------------------------------------------------------------
-
-void *memmove(void *dest, const void *src, size_t size) {
-	char *dest_bytes = (char *)dest;
-	char *src_bytes = (char *)src;
-	if(dest_bytes < src_bytes) {
-		return forward_copy(dest, src, size);
-	}else if(dest_bytes > src_bytes) {
-		for(size_t i = 0; i < size; i++)
-			dest_bytes[size - i - 1] = src_bytes[size - i - 1];
-	}
-	return dest;
-}
-
-size_t strlen(const char *s) {
-	size_t len = 0;
-	for(size_t i = 0; s[i]; i++)
-		len++;
-	return len;
-}