Updated libc

libc/Makefile

@@ -1,5 +1,6 @@
 build:
 	cp -r include/* ../out/system/include
+	cp ../../Kernel/syscalls.h ../out/system/include/sys
 	make --quiet -C runtime build
 	make --quiet -C src build
 

libc/include/aux.h

@@ -0,0 +1,54 @@
+#ifndef __FENNIX_LIBC_AUX_H__
+#define __FENNIX_LIBC_AUX_H__
+
+#include <types.h>
+
+#define AT_NULL 0
+#define AT_IGNORE 1
+#define AT_EXECFD 2
+#define AT_PHDR 3
+#define AT_PHENT 4
+#define AT_PHNUM 5
+#define AT_PAGESZ 6
+#define AT_BASE 7
+#define AT_FLAGS 8
+#define AT_ENTRY 9
+#define AT_NOTELF 10
+#define AT_UID 11
+#define AT_EUID 12
+#define AT_GID 13
+#define AT_EGID 14
+#define AT_PLATFORM 15
+#define AT_HWCAP 16
+#define AT_CLKTCK 17
+#define AT_SECURE 23
+#define AT_BASE_PLATFORM 24
+#define AT_RANDOM 25
+#define AT_HWCAP2 26
+#define AT_EXECFN 31
+#define AT_SYSINFO 32
+#define AT_SYSINFO_EHDR 33
+#define AT_L1I_CACHESHAPE 34
+#define AT_L1D_CACHESHAPE 35
+#define AT_L2_CACHESHAPE 36
+#define AT_L3_CACHESHAPE 37
+#define AT_L1I_CACHESIZE 40
+#define AT_L1I_CACHEGEOMETRY 41
+#define AT_L1D_CACHESIZE 42
+#define AT_L1D_CACHEGEOMETRY 43
+#define AT_L2_CACHESIZE 44
+#define AT_L2_CACHEGEOMETRY 45
+#define AT_L3_CACHESIZE 46
+#define AT_L3_CACHEGEOMETRY 47
+#define AT_MINSIGSTKSZ 51
+
+typedef struct
+{
+    unsigned long a_type;
+    union
+    {
+        unsigned long a_val;
+    } a_un;
+} Elf64_auxv_t;
+
+#endif // !__FENNIX_LIBC_AUX_H__

libc/include/stdarg.h

@@ -0,0 +1,11 @@
+#ifndef _STDARG_H
+#define _STDARG_H
+
+typedef __builtin_va_list va_list;
+
+#define va_start(ap, last) __builtin_va_start(ap, last)
+#define va_end(ap) __builtin_va_end(ap)
+#define va_arg(ap, type) __builtin_va_arg(ap, type)
+#define va_copy(dest, src) __builtin_va_copy(dest, src)
+
+#endif // !_STDARG_H

libc/include/stddef.h

@@ -0,0 +1,42 @@
+#ifndef _STDDEF_H
+#define _STDDEF_H
+
+#define NULL ((void *)0)
+
+typedef __INT8_TYPE__ int8_t;
+typedef __INT16_TYPE__ int16_t;
+typedef __INT32_TYPE__ int32_t;
+typedef __INT64_TYPE__ int64_t;
+typedef __UINT8_TYPE__ uint8_t;
+typedef __UINT16_TYPE__ uint16_t;
+typedef __UINT32_TYPE__ uint32_t;
+typedef __UINT64_TYPE__ uint64_t;
+
+typedef __INT_LEAST8_TYPE__ int_least8_t;
+typedef __INT_LEAST16_TYPE__ int_least16_t;
+typedef __INT_LEAST32_TYPE__ int_least32_t;
+typedef __INT_LEAST64_TYPE__ int_least64_t;
+typedef __UINT_LEAST8_TYPE__ uint_least8_t;
+typedef __UINT_LEAST16_TYPE__ uint_least16_t;
+typedef __UINT_LEAST32_TYPE__ uint_least32_t;
+typedef __UINT_LEAST64_TYPE__ uint_least64_t;
+
+typedef __INT_FAST8_TYPE__ int_fast8_t;
+typedef __INT_FAST16_TYPE__ int_fast16_t;
+typedef __INT_FAST32_TYPE__ int_fast32_t;
+typedef __INT_FAST64_TYPE__ int_fast64_t;
+typedef __UINT_FAST8_TYPE__ uint_fast8_t;
+typedef __UINT_FAST16_TYPE__ uint_fast16_t;
+typedef __UINT_FAST32_TYPE__ uint_fast32_t;
+typedef __UINT_FAST64_TYPE__ uint_fast64_t;
+
+typedef __INTPTR_TYPE__ intptr_t;
+typedef __UINTPTR_TYPE__ uintptr_t;
+
+typedef __INTMAX_TYPE__ intmax_t;
+typedef __UINTMAX_TYPE__ uintmax_t;
+
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+typedef __SIZE_TYPE__ size_t;
+
+#endif // !_STDDEF_H

libc/include/stdio.h

@@ -16,19 +16,24 @@ extern "C"
 {
 #endif
 
+    extern FILE *stdin;
+    extern FILE *stdout;
     extern FILE *stderr;
-#define stderr stderr
 
-    int fclose(FILE *);
-    int fflush(FILE *);
-    FILE *fopen(const char *, const char *);
-    int fprintf(FILE *, const char *, ...);
-    size_t fread(void *, size_t, size_t, FILE *);
-    int fseek(FILE *, long, int);
-    long ftell(FILE *);
-    size_t fwrite(const void *, size_t, size_t, FILE *);
-    void setbuf(FILE *, char *);
-    int vfprintf(FILE *, const char *, va_list);
+    int fclose(FILE *stream);
+    int fflush(FILE *stream);
+    FILE *fopen(const char *filename, const char *mode);
+    int fprintf(FILE *stream, const char *format, ...);
+    int printf(const char *format, ...);
+    size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
+    int fseek(FILE *stream, long offset, int whence);
+    long ftell(FILE *stream);
+    size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
+    void setbuf(FILE *stream, char *buf);
+    int vfprintf(FILE *stream, const char *format, va_list arg);
+
+    int puts(const char *s);
+    int putchar(int c);
 
 #ifdef __cplusplus
 }

libc/include/stdlib.h

@@ -9,11 +9,15 @@ extern "C"
 #endif
 
     void abort(void);
-    int atexit(void (*)(void));
-    int atoi(const char *);
-    void free(void *);
-    char *getenv(const char *);
-    void *malloc(size_t);
+    int atexit(void (*function)(void));
+    void exit(int status);
+    int atoi(const char *nptr);
+    char *getenv(const char *name);
+
+    void *malloc(size_t Size);
+    void *realloc(void *Address, size_t Size);
+    void *calloc(size_t Count, size_t Size);
+    void free(void *Address);
 
 #ifdef __cplusplus
 }

libc/runtime/crt1.S

@@ -8,6 +8,8 @@ _start:
 	pushq %rbp
 	movq %rsp, %rbp
 
+	pushq %rcx
+	pushq %rdx
 	pushq %rsi
 	pushq %rdi
 
@@ -15,6 +17,8 @@ _start:
 
 	popq %rdi
 	popq %rsi
+	popq %rdx
+	popq %rcx
 
 	call main
 	movl %eax, %edi

libc/src/Lock.cpp

@@ -0,0 +1,35 @@
+#include "lock.hpp"
+#include <stdio.h>
+
+void LockClass::DeadLock(SpinLockData Lock)
+{
+    fprintf(stdout, "Potential deadlock in lock '%s' held by '%s'! %ld locks in queue.",
+            Lock.AttemptingToGet, Lock.CurrentHolder, Lock.Count);
+}
+
+int LockClass::Lock(const char *FunctionName)
+{
+    LockData.AttemptingToGet = FunctionName;
+Retry:
+    unsigned int i = 0;
+    while (__atomic_exchange_n(&IsLocked, true, __ATOMIC_ACQUIRE) && ++i < 0x10000000)
+        ;
+    if (i >= 0x10000000)
+    {
+        DeadLock(LockData);
+        goto Retry;
+    }
+    LockData.Count++;
+    LockData.CurrentHolder = FunctionName;
+    __sync_synchronize();
+    return 0;
+}
+
+int LockClass::Unlock()
+{
+    __sync_synchronize();
+    __atomic_store_n(&IsLocked, false, __ATOMIC_RELEASE);
+    LockData.Count--;
+    IsLocked = false;
+    return 0;
+}

libc/src/Makefile

@@ -7,17 +7,18 @@ OBJECT_NAME=lib$(NAME).a
 
 OUTPUT_DIR=../../out/system/lib/
 
-CC = ../../../$(COMPILER_PATH)/$(COMPILER_ARCH)gcc
-AS = ../../../$(COMPILER_PATH)/$(COMPILER_ARCH)as
-AR = ../../../$(COMPILER_PATH)/$(COMPILER_ARCH)ar
+CC = ../../../$(TC_COMPILER_PATH)/$(TC_COMPILER_ARCH)gcc
+AS = ../../../$(TC_COMPILER_PATH)/$(TC_COMPILER_ARCH)as
+AR = ../../../$(TC_COMPILER_PATH)/$(TC_COMPILER_ARCH)ar
 NASM = /usr/bin/nasm
 
 C_SOURCES = $(shell find ./ -type f -name '*.c')
+CPP_SOURCES = $(shell find ./ -type f -name '*.cpp')
 S_SOURCES = $(shell find ./ -type f -name '*.S')
 ASM_SOURCES = $(shell find ./ -type f -name '*.asm')
-OBJ = ${C_SOURCES:.c=.o} ${ASM_SOURCES:.asm=.o} ${S_SOURCES:.S=.o}
+OBJ = ${C_SOURCES:.c=.o} ${CPP_SOURCES:.cpp=.o} ${ASM_SOURCES:.asm=.o} ${S_SOURCES:.S=.o}
 
-INCLUDE_DIR = ../include
+INCLUDE = ../include
 
 ifeq ($(OSARCH), amd64)
 ASM_ARCH := elf64
@@ -25,17 +26,17 @@ else ifeq ($(OSARCH), i686)
 ASM_ARCH := elf32
 endif
 
-CFLAGS := -fPIC -mno-red-zone -I$(INCLUDE_DIR)
+CFLAGS := -fPIC -mno-red-zone -I$(INCLUDE)
 
 build: $(OBJECT_NAME)
 
 $(OBJECT_NAME): $(OBJ)
-	$(AR) rcs  $(OUTPUT_DIR)$@ $(OBJ)
+	$(AR) rcs $(OUTPUT_DIR)$@ $(OBJ)
 
-%.o: %.c $(HEADERS) $(HEADERS2)
+%.o: %.c
 	$(CC) $(CFLAGS) -std=c17 -c $< -o $@
 
-%.o: %.cpp $(HEADERS) $(HEADERS2)
+%.o: %.cpp
 	$(CC) $(CFLAGS) -std=c++20 -c $< -o $@
 
 %.o: %.S

libc/src/lock.hpp

@@ -0,0 +1,50 @@
+#ifndef __FENNIX_KERNEL_LOCK_H__
+#define __FENNIX_KERNEL_LOCK_H__
+
+#include <types.h>
+
+#ifdef __cplusplus
+/** @brief Please use this macro to create a new lock. */
+class LockClass
+{
+    struct SpinLockData
+    {
+        uint64_t LockData = 0x0;
+        const char *CurrentHolder = "(nul)";
+        const char *AttemptingToGet = "(nul)";
+        uint64_t Count = 0;
+    };
+    void DeadLock(SpinLockData Lock);
+
+private:
+    SpinLockData LockData;
+    bool IsLocked = false;
+
+public:
+    SpinLockData *GetLockData() { return &LockData; }
+    int Lock(const char *FunctionName);
+    int Unlock();
+};
+
+/** @brief Please use this macro to create a new smart lock. */
+class SmartLockClass
+{
+private:
+    LockClass *LockPointer = nullptr;
+
+public:
+    SmartLockClass(LockClass &Lock, const char *FunctionName)
+    {
+        this->LockPointer = &Lock;
+        this->LockPointer->Lock(FunctionName);
+    }
+    ~SmartLockClass() { this->LockPointer->Unlock(); }
+};
+
+/** @brief Create a new lock (can be used with SmartCriticalSection). */
+#define NewLock(Name) LockClass Name
+/** @brief Simple lock that is automatically released when the scope ends. */
+#define SmartLock(LockClassName) SmartLockClass CONCAT(lock##_, __COUNTER__)(LockClassName, __FUNCTION__)
+
+#endif // __cplusplus
+#endif // !__FENNIX_KERNEL_LOCK_H__

libc/src/mem/impl.cpp

@@ -0,0 +1,26 @@
+#include <types.h>
+#include "../lock.hpp"
+
+#include "../../../../Kernel/syscalls.h"
+
+NewLock(liballocLock);
+
+extern "C" int liballoc_lock()
+{
+    return liballocLock.Lock(__FUNCTION__);
+}
+
+extern "C" int liballoc_unlock()
+{
+    return liballocLock.Unlock();
+}
+
+extern "C" void *liballoc_alloc(size_t Pages)
+{
+    return (void *)syscall1(_RequestPages, Pages);
+}
+
+extern "C" int liballoc_free(void *Address, size_t Pages)
+{
+    return syscall2(_FreePages, (uint64_t)Address, Pages);
+}

libc/src/mem/liballoc_1_1.c

@@ -0,0 +1,789 @@
+#include "liballoc_1_1.h"
+
+/**  Durand's Amazing Super Duper Memory functions.  */
+
+#define VERSION "1.1"
+#define ALIGNMENT 16ul // 4ul				///< This is the byte alignment that memory must be allocated on. IMPORTANT for GTK and other stuff.
+
+#define ALIGN_TYPE char					   /// unsigned char[16] /// unsigned short
+#define ALIGN_INFO sizeof(ALIGN_TYPE) * 16 ///< Alignment information is stored right before the pointer. This is the number of bytes of information stored there.
+
+#define USE_CASE1
+#define USE_CASE2
+#define USE_CASE3
+#define USE_CASE4
+#define USE_CASE5
+
+/** This macro will conveniently align our pointer upwards */
+#define ALIGN(ptr)                                       \
+	if (ALIGNMENT > 1)                                   \
+	{                                                    \
+		uintptr_t diff;                                  \
+		ptr = (void *)((uintptr_t)ptr + ALIGN_INFO);     \
+		diff = (uintptr_t)ptr & (ALIGNMENT - 1);         \
+		if (diff != 0)                                   \
+		{                                                \
+			diff = ALIGNMENT - diff;                     \
+			ptr = (void *)((uintptr_t)ptr + diff);       \
+		}                                                \
+		*((ALIGN_TYPE *)((uintptr_t)ptr - ALIGN_INFO)) = \
+			diff + ALIGN_INFO;                           \
+	}
+
+#define UNALIGN(ptr)                                                     \
+	if (ALIGNMENT > 1)                                                   \
+	{                                                                    \
+		uintptr_t diff = *((ALIGN_TYPE *)((uintptr_t)ptr - ALIGN_INFO)); \
+		if (diff < (ALIGNMENT + ALIGN_INFO))                             \
+		{                                                                \
+			ptr = (void *)((uintptr_t)ptr - diff);                       \
+		}                                                                \
+	}
+
+#define LIBALLOC_MAGIC 0xc001c0de
+#define LIBALLOC_DEAD 0xdeaddead
+
+// #define LIBALLOCDEBUG 1
+#define LIBALLOCINFO 1
+
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+#include <stdio.h>
+#include <stdlib.h>
+// #include <debug.h>
+
+#define FLUSH() fflush(stdout)
+#define atexit(x) atexit(x)
+// #define printf(m, ...) trace(m, ##__VA_ARGS__)
+
+#endif
+
+/** A structure found at the top of all system allocated
+ * memory blocks. It details the usage of the memory block.
+ */
+struct liballoc_major
+{
+	struct liballoc_major *prev;  ///< Linked list information.
+	struct liballoc_major *next;  ///< Linked list information.
+	unsigned int pages;			  ///< The number of pages in the block.
+	unsigned int size;			  ///< The number of pages in the block.
+	unsigned int usage;			  ///< The number of bytes used in the block.
+	struct liballoc_minor *first; ///< A pointer to the first allocated memory in the block.
+};
+
+/** This is a structure found at the beginning of all
+ * sections in a major block which were allocated by a
+ * malloc, calloc, realloc call.
+ */
+struct liballoc_minor
+{
+	struct liballoc_minor *prev;  ///< Linked list information.
+	struct liballoc_minor *next;  ///< Linked list information.
+	struct liballoc_major *block; ///< The owning block. A pointer to the major structure.
+	unsigned int magic;			  ///< A magic number to idenfity correctness.
+	unsigned int size;			  ///< The size of the memory allocated. Could be 1 byte or more.
+	unsigned int req_size;		  ///< The size of memory requested.
+};
+
+static struct liballoc_major *l_memRoot = NULL; ///< The root memory block acquired from the system.
+static struct liballoc_major *l_bestBet = NULL; ///< The major with the most free memory.
+
+static unsigned int l_pageSize = 4096;	   ///< The size of an individual page. Set up in liballoc_init.
+static unsigned int l_pageCount = 16;	   ///< The number of pages to request per chunk. Set up in liballoc_init.
+static unsigned long long l_allocated = 0; ///< Running total of allocated memory.
+static unsigned long long l_inuse = 0;	   ///< Running total of used memory.
+
+static long long l_warningCount = 0;	 ///< Number of warnings encountered
+static long long l_errorCount = 0;		 ///< Number of actual errors
+static long long l_possibleOverruns = 0; ///< Number of possible overruns
+
+// ***********   HELPER FUNCTIONS  *******************************
+
+static void *liballoc_memset(void *s, int c, size_t n)
+{
+	unsigned int i;
+	for (i = 0; i < n; i++)
+		((char *)s)[i] = c;
+
+	return s;
+}
+static void *liballoc_memcpy(void *s1, const void *s2, size_t n)
+{
+	char *cdest;
+	char *csrc;
+	unsigned int *ldest = (unsigned int *)s1;
+	unsigned int *lsrc = (unsigned int *)s2;
+
+	while (n >= sizeof(unsigned int))
+	{
+		*ldest++ = *lsrc++;
+		n -= sizeof(unsigned int);
+	}
+
+	cdest = (char *)ldest;
+	csrc = (char *)lsrc;
+
+	while (n > 0)
+	{
+		*cdest++ = *csrc++;
+		n -= 1;
+	}
+
+	return s1;
+}
+
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+static void liballoc_dump()
+{
+#ifdef LIBALLOCDEBUG
+	struct liballoc_major *maj = l_memRoot;
+	struct liballoc_minor *min = NULL;
+#endif
+
+	printf("liballoc: ------ Memory data ---------------\n");
+	printf("liballoc: System memory allocated: %i bytes\n", l_allocated);
+	printf("liballoc: Memory in used (malloc'ed): %i bytes\n", l_inuse);
+	printf("liballoc: Warning count: %i\n", l_warningCount);
+	printf("liballoc: Error count: %i\n", l_errorCount);
+	printf("liballoc: Possible overruns: %i\n", l_possibleOverruns);
+
+#ifdef LIBALLOCDEBUG
+	while (maj != NULL)
+	{
+		printf("liballoc: %x: total = %i, used = %i\n",
+			   maj,
+			   maj->size,
+			   maj->usage);
+
+		min = maj->first;
+		while (min != NULL)
+		{
+			printf("liballoc:    %x: %i bytes\n",
+				   min,
+				   min->size);
+			min = min->next;
+		}
+
+		maj = maj->next;
+	}
+#endif
+
+	FLUSH();
+}
+#endif
+
+// ***************************************************************
+
+static struct liballoc_major *allocate_new_page(unsigned int size)
+{
+	unsigned int st;
+	struct liballoc_major *maj;
+
+	// This is how much space is required.
+	st = size + sizeof(struct liballoc_major);
+	st += sizeof(struct liballoc_minor);
+
+	// Perfect amount of space?
+	if ((st % l_pageSize) == 0)
+		st = st / (l_pageSize);
+	else
+		st = st / (l_pageSize) + 1;
+	// No, add the buffer.
+
+	// Make sure it's >= the minimum size.
+	if (st < l_pageCount)
+		st = l_pageCount;
+
+	maj = (struct liballoc_major *)liballoc_alloc(st);
+
+	if (maj == NULL)
+	{
+		l_warningCount += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+		printf("liballoc: WARNING: liballoc_alloc( %i ) return NULL\n", st);
+		FLUSH();
+#endif
+		return NULL; // uh oh, we ran out of memory.
+	}
+
+	maj->prev = NULL;
+	maj->next = NULL;
+	maj->pages = st;
+	maj->size = st * l_pageSize;
+	maj->usage = sizeof(struct liballoc_major);
+	maj->first = NULL;
+
+	l_allocated += maj->size;
+
+#ifdef LIBALLOCDEBUG
+	printf("liballoc: Resource allocated %x of %i pages (%i bytes) for %i size.\n", maj, st, maj->size, size);
+
+	printf("liballoc: Total memory usage = %i KB\n", (int)((l_allocated / (1024))));
+	FLUSH();
+#endif
+
+	return maj;
+}
+
+void *PREFIX(malloc)(size_t req_size)
+{
+	int startedBet = 0;
+	unsigned long long bestSize = 0;
+	void *p = NULL;
+	uintptr_t diff;
+	struct liballoc_major *maj;
+	struct liballoc_minor *min;
+	struct liballoc_minor *new_min;
+	unsigned long size = req_size;
+
+	// For alignment, we adjust size so there's enough space to align.
+	if (ALIGNMENT > 1)
+	{
+		size += ALIGNMENT + ALIGN_INFO;
+	}
+	// So, ideally, we really want an alignment of 0 or 1 in order
+	// to save space.
+
+	liballoc_lock();
+
+	if (size == 0)
+	{
+		l_warningCount += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+		printf("liballoc: WARNING: alloc( 0 ) called from %x\n",
+			   __builtin_return_address(0));
+		FLUSH();
+#endif
+		liballoc_unlock();
+		return PREFIX(malloc)(1);
+	}
+
+	if (l_memRoot == NULL)
+	{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+#ifdef LIBALLOCDEBUG
+		printf("liballoc: initialization of liballoc " VERSION "\n");
+#endif
+		atexit(liballoc_dump);
+		FLUSH();
+#endif
+
+		// This is the first time we are being used.
+		l_memRoot = allocate_new_page(size);
+		if (l_memRoot == NULL)
+		{
+			liballoc_unlock();
+#ifdef LIBALLOCDEBUG
+			printf("liballoc: initial l_memRoot initialization failed\n", p);
+			FLUSH();
+#endif
+			return NULL;
+		}
+
+#ifdef LIBALLOCDEBUG
+		printf("liballoc: set up first memory major %x\n", l_memRoot);
+		FLUSH();
+#endif
+	}
+
+#ifdef LIBALLOCDEBUG
+	printf("liballoc: %x PREFIX(malloc)( %i ): ",
+		   __builtin_return_address(0),
+		   size);
+	FLUSH();
+#endif
+
+	// Now we need to bounce through every major and find enough space....
+
+	maj = l_memRoot;
+	startedBet = 0;
+
+	// Start at the best bet....
+	if (l_bestBet != NULL)
+	{
+		bestSize = l_bestBet->size - l_bestBet->usage;
+
+		if (bestSize > (size + sizeof(struct liballoc_minor)))
+		{
+			maj = l_bestBet;
+			startedBet = 1;
+		}
+	}
+
+	while (maj != NULL)
+	{
+		diff = maj->size - maj->usage;
+		// free memory in the block
+
+		if (bestSize < diff)
+		{
+			// Hmm.. this one has more memory then our bestBet. Remember!
+			l_bestBet = maj;
+			bestSize = diff;
+		}
+
+#ifdef USE_CASE1
+
+		// CASE 1:  There is not enough space in this major block.
+		if (diff < (size + sizeof(struct liballoc_minor)))
+		{
+#ifdef LIBALLOCDEBUG
+			printf("CASE 1: Insufficient space in block %x\n", maj);
+			FLUSH();
+#endif
+
+			// Another major block next to this one?
+			if (maj->next != NULL)
+			{
+				maj = maj->next; // Hop to that one.
+				continue;
+			}
+
+			if (startedBet == 1) // If we started at the best bet,
+			{					 // let's start all over again.
+				maj = l_memRoot;
+				startedBet = 0;
+				continue;
+			}
+
+			// Create a new major block next to this one and...
+			maj->next = allocate_new_page(size); // next one will be okay.
+			if (maj->next == NULL)
+				break; // no more memory.
+			maj->next->prev = maj;
+			maj = maj->next;
+
+			// .. fall through to CASE 2 ..
+		}
+
+#endif
+
+#ifdef USE_CASE2
+
+		// CASE 2: It's a brand new block.
+		if (maj->first == NULL)
+		{
+			maj->first = (struct liballoc_minor *)((uintptr_t)maj + sizeof(struct liballoc_major));
+
+			maj->first->magic = LIBALLOC_MAGIC;
+			maj->first->prev = NULL;
+			maj->first->next = NULL;
+			maj->first->block = maj;
+			maj->first->size = size;
+			maj->first->req_size = req_size;
+			maj->usage += size + sizeof(struct liballoc_minor);
+
+			l_inuse += size;
+
+			p = (void *)((uintptr_t)(maj->first) + sizeof(struct liballoc_minor));
+
+			ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+			printf("CASE 2: returning %x\n", p);
+			FLUSH();
+#endif
+			liballoc_unlock(); // release the lock
+			return p;
+		}
+
+#endif
+
+#ifdef USE_CASE3
+
+		// CASE 3: Block in use and enough space at the start of the block.
+		diff = (uintptr_t)(maj->first);
+		diff -= (uintptr_t)maj;
+		diff -= sizeof(struct liballoc_major);
+
+		if (diff >= (size + sizeof(struct liballoc_minor)))
+		{
+			// Yes, space in front. Squeeze in.
+			maj->first->prev = (struct liballoc_minor *)((uintptr_t)maj + sizeof(struct liballoc_major));
+			maj->first->prev->next = maj->first;
+			maj->first = maj->first->prev;
+
+			maj->first->magic = LIBALLOC_MAGIC;
+			maj->first->prev = NULL;
+			maj->first->block = maj;
+			maj->first->size = size;
+			maj->first->req_size = req_size;
+			maj->usage += size + sizeof(struct liballoc_minor);
+
+			l_inuse += size;
+
+			p = (void *)((uintptr_t)(maj->first) + sizeof(struct liballoc_minor));
+			ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+			printf("CASE 3: returning %x\n", p);
+			FLUSH();
+#endif
+			liballoc_unlock(); // release the lock
+			return p;
+		}
+
+#endif
+
+#ifdef USE_CASE4
+
+		// CASE 4: There is enough space in this block. But is it contiguous?
+		min = maj->first;
+
+		// Looping within the block now...
+		while (min != NULL)
+		{
+			// CASE 4.1: End of minors in a block. Space from last and end?
+			if (min->next == NULL)
+			{
+				// the rest of this block is free...  is it big enough?
+				diff = (uintptr_t)(maj) + maj->size;
+				diff -= (uintptr_t)min;
+				diff -= sizeof(struct liballoc_minor);
+				diff -= min->size;
+				// minus already existing usage..
+
+				if (diff >= (size + sizeof(struct liballoc_minor)))
+				{
+					// yay....
+					min->next = (struct liballoc_minor *)((uintptr_t)min + sizeof(struct liballoc_minor) + min->size);
+					min->next->prev = min;
+					min = min->next;
+					min->next = NULL;
+					min->magic = LIBALLOC_MAGIC;
+					min->block = maj;
+					min->size = size;
+					min->req_size = req_size;
+					maj->usage += size + sizeof(struct liballoc_minor);
+
+					l_inuse += size;
+
+					p = (void *)((uintptr_t)min + sizeof(struct liballoc_minor));
+					ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+					printf("CASE 4.1: returning %x\n", p);
+					FLUSH();
+#endif
+					liballoc_unlock(); // release the lock
+					return p;
+				}
+			}
+
+			// CASE 4.2: Is there space between two minors?
+			if (min->next != NULL)
+			{
+				// is the difference between here and next big enough?
+				diff = (uintptr_t)(min->next);
+				diff -= (uintptr_t)min;
+				diff -= sizeof(struct liballoc_minor);
+				diff -= min->size;
+				// minus our existing usage.
+
+				if (diff >= (size + sizeof(struct liballoc_minor)))
+				{
+					// yay......
+					new_min = (struct liballoc_minor *)((uintptr_t)min + sizeof(struct liballoc_minor) + min->size);
+
+					new_min->magic = LIBALLOC_MAGIC;
+					new_min->next = min->next;
+					new_min->prev = min;
+					new_min->size = size;
+					new_min->req_size = req_size;
+					new_min->block = maj;
+					min->next->prev = new_min;
+					min->next = new_min;
+					maj->usage += size + sizeof(struct liballoc_minor);
+
+					l_inuse += size;
+
+					p = (void *)((uintptr_t)new_min + sizeof(struct liballoc_minor));
+					ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+					printf("CASE 4.2: returning %x\n", p);
+					FLUSH();
+#endif
+
+					liballoc_unlock(); // release the lock
+					return p;
+				}
+			} // min->next != NULL
+
+			min = min->next;
+		} // while min != NULL ...
+
+#endif
+
+#ifdef USE_CASE5
+
+		// CASE 5: Block full! Ensure next block and loop.
+		if (maj->next == NULL)
+		{
+#ifdef LIBALLOCDEBUG
+			printf("CASE 5: block full\n");
+			FLUSH();
+#endif
+
+			if (startedBet == 1)
+			{
+				maj = l_memRoot;
+				startedBet = 0;
+				continue;
+			}
+
+			// we've run out. we need more...
+			maj->next = allocate_new_page(size); // next one guaranteed to be okay
+			if (maj->next == NULL)
+				break; //  uh oh,  no more memory.....
+			maj->next->prev = maj;
+		}
+
+#endif
+
+		maj = maj->next;
+	} // while (maj != NULL)
+
+	liballoc_unlock(); // release the lock
+
+#ifdef LIBALLOCDEBUG
+	printf("All cases exhausted. No memory available.\n");
+	FLUSH();
+#endif
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+	printf("liballoc: WARNING: PREFIX(malloc)( %i ) returning NULL.\n", size);
+	liballoc_dump();
+	FLUSH();
+#endif
+	return NULL;
+}
+
+void PREFIX(free)(void *ptr)
+{
+	struct liballoc_minor *min;
+	struct liballoc_major *maj;
+
+	if (ptr == NULL)
+	{
+		l_warningCount += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+		printf("liballoc: WARNING: PREFIX(free)( NULL ) called from %x\n",
+			   __builtin_return_address(0));
+		FLUSH();
+#endif
+		return;
+	}
+
+	UNALIGN(ptr);
+
+	liballoc_lock(); // lockit
+
+	min = (struct liballoc_minor *)((uintptr_t)ptr - sizeof(struct liballoc_minor));
+
+	if (min->magic != LIBALLOC_MAGIC)
+	{
+		l_errorCount += 1;
+
+		// Check for overrun errors. For all bytes of LIBALLOC_MAGIC
+		if (
+			((min->magic & 0xFFFFFF) == (LIBALLOC_MAGIC & 0xFFFFFF)) ||
+			((min->magic & 0xFFFF) == (LIBALLOC_MAGIC & 0xFFFF)) ||
+			((min->magic & 0xFF) == (LIBALLOC_MAGIC & 0xFF)))
+		{
+			l_possibleOverruns += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Possible 1-3 byte overrun for magic %x != %x\n",
+				   min->magic,
+				   LIBALLOC_MAGIC);
+			FLUSH();
+#endif
+		}
+
+		if (min->magic == LIBALLOC_DEAD)
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: multiple PREFIX(free)() attempt on %x from %x.\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+		else
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Bad PREFIX(free)( %x ) called from %x\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+
+		// being lied to...
+		liballoc_unlock(); // release the lock
+		return;
+	}
+
+#ifdef LIBALLOCDEBUG
+	printf("liballoc: %x PREFIX(free)( %x ): ",
+		   __builtin_return_address(0),
+		   ptr);
+	FLUSH();
+#endif
+
+	maj = min->block;
+
+	l_inuse -= min->size;
+
+	maj->usage -= (min->size + sizeof(struct liballoc_minor));
+	min->magic = LIBALLOC_DEAD; // No mojo.
+
+	if (min->next != NULL)
+		min->next->prev = min->prev;
+	if (min->prev != NULL)
+		min->prev->next = min->next;
+
+	if (min->prev == NULL)
+		maj->first = min->next;
+	// Might empty the block. This was the first
+	// minor.
+
+	// We need to clean up after the majors now....
+
+	if (maj->first == NULL) // Block completely unused.
+	{
+		if (l_memRoot == maj)
+			l_memRoot = maj->next;
+		if (l_bestBet == maj)
+			l_bestBet = NULL;
+		if (maj->prev != NULL)
+			maj->prev->next = maj->next;
+		if (maj->next != NULL)
+			maj->next->prev = maj->prev;
+		l_allocated -= maj->size;
+
+		liballoc_free(maj, maj->pages);
+	}
+	else
+	{
+		if (l_bestBet != NULL)
+		{
+			int bestSize = l_bestBet->size - l_bestBet->usage;
+			int majSize = maj->size - maj->usage;
+
+			if (majSize > bestSize)
+				l_bestBet = maj;
+		}
+	}
+
+#ifdef LIBALLOCDEBUG
+	printf("OK\n");
+	FLUSH();
+#endif
+
+	liballoc_unlock(); // release the lock
+}
+
+void *PREFIX(calloc)(size_t nobj, size_t size)
+{
+	int real_size;
+	void *p;
+
+	real_size = nobj * size;
+
+	p = PREFIX(malloc)(real_size);
+
+	liballoc_memset(p, 0, real_size);
+
+	return p;
+}
+
+void *PREFIX(realloc)(void *p, size_t size)
+{
+	void *ptr;
+	struct liballoc_minor *min;
+	unsigned int real_size;
+
+	// Honour the case of size == 0 => free old and return NULL
+	if (size == 0)
+	{
+		PREFIX(free)
+		(p);
+		return NULL;
+	}
+
+	// In the case of a NULL pointer, return a simple malloc.
+	if (p == NULL)
+		return PREFIX(malloc)(size);
+
+	// Unalign the pointer if required.
+	ptr = p;
+	UNALIGN(ptr);
+
+	liballoc_lock(); // lockit
+
+	min = (struct liballoc_minor *)((uintptr_t)ptr - sizeof(struct liballoc_minor));
+
+	// Ensure it is a valid structure.
+	if (min->magic != LIBALLOC_MAGIC)
+	{
+		l_errorCount += 1;
+
+		// Check for overrun errors. For all bytes of LIBALLOC_MAGIC
+		if (
+			((min->magic & 0xFFFFFF) == (LIBALLOC_MAGIC & 0xFFFFFF)) ||
+			((min->magic & 0xFFFF) == (LIBALLOC_MAGIC & 0xFFFF)) ||
+			((min->magic & 0xFF) == (LIBALLOC_MAGIC & 0xFF)))
+		{
+			l_possibleOverruns += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Possible 1-3 byte overrun for magic %x != %x\n",
+				   min->magic,
+				   LIBALLOC_MAGIC);
+			FLUSH();
+#endif
+		}
+
+		if (min->magic == LIBALLOC_DEAD)
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: multiple PREFIX(free)() attempt on %x from %x.\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+		else
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Bad PREFIX(free)( %x ) called from %x\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+
+		// being lied to...
+		liballoc_unlock(); // release the lock
+		return NULL;
+	}
+
+	// Definitely a memory block.
+
+	real_size = min->req_size;
+
+	if (real_size >= size)
+	{
+		min->req_size = size;
+		liballoc_unlock();
+		return p;
+	}
+
+	liballoc_unlock();
+
+	// If we got here then we're reallocating to a block bigger than us.
+	ptr = PREFIX(malloc)(size); // We need to allocate new memory
+	liballoc_memcpy(ptr, p, real_size);
+	PREFIX(free)
+	(p);
+
+	return ptr;
+}

libc/src/mem/liballoc_1_1.h

@@ -0,0 +1,74 @@
+#ifndef _LIBALLOC_H
+#define _LIBALLOC_H
+
+#include <types.h>
+
+/** \defgroup ALLOCHOOKS liballoc hooks
+ *
+ * These are the OS specific functions which need to
+ * be implemented on any platform that the library
+ * is expected to work on.
+ */
+
+/** @{ */
+
+// If we are told to not define our own size_t, then we skip the define.
+// #define _HAVE_UINTPTR_T
+// typedef	unsigned long	uintptr_t;
+
+// This lets you prefix malloc and friends
+#define PREFIX(func) __##func
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /** This function is supposed to lock the memory data structures. It
+     * could be as simple as disabling interrupts or acquiring a spinlock.
+     * It's up to you to decide.
+     *
+     * \return 0 if the lock was acquired successfully. Anything else is
+     * failure.
+     */
+    extern int liballoc_lock();
+
+    /** This function unlocks what was previously locked by the liballoc_lock
+     * function.  If it disabled interrupts, it enables interrupts. If it
+     * had acquiried a spinlock, it releases the spinlock. etc.
+     *
+     * \return 0 if the lock was successfully released.
+     */
+    extern int liballoc_unlock();
+
+    /** This is the hook into the local system which allocates pages. It
+     * accepts an integer parameter which is the number of pages
+     * required.  The page size was set up in the liballoc_init function.
+     *
+     * \return NULL if the pages were not allocated.
+     * \return A pointer to the allocated memory.
+     */
+    extern void *liballoc_alloc(size_t);
+
+    /** This frees previously allocated memory. The void* parameter passed
+     * to the function is the exact same value returned from a previous
+     * liballoc_alloc call.
+     *
+     * The integer value is the number of pages to free.
+     *
+     * \return 0 if the memory was successfully freed.
+     */
+    extern int liballoc_free(void *, size_t);
+
+    extern void *PREFIX(malloc)(size_t);          ///< The standard function.
+    extern void *PREFIX(realloc)(void *, size_t); ///< The standard function.
+    extern void *PREFIX(calloc)(size_t, size_t);  ///< The standard function.
+    extern void PREFIX(free)(void *);             ///< The standard function.
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */
+
+#endif

libc/src/print/printf.h

@@ -0,0 +1,194 @@
+/**
+ * @author (c) Eyal Rozenberg <eyalroz1@gmx.com>
+ *             2021-2022, Haifa, Palestine/Israel
+ * @author (c) Marco Paland (info@paland.com)
+ *             2014-2019, PALANDesign Hannover, Germany
+ *
+ * @note Others have made smaller contributions to this file: see the
+ * contributors page at https://github.com/eyalroz/printf/graphs/contributors
+ * or ask one of the authors.
+ *
+ * @brief Small stand-alone implementation of the printf family of functions
+ * (`(v)printf`, `(v)s(n)printf` etc., geared towards use on embedded systems with
+ * a very limited resources.
+ *
+ * @note the implementations are thread-safe; re-entrant; use no functions from
+ * the standard library; and do not dynamically allocate any memory.
+ *
+ * @license The MIT License (MIT)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef PRINTF_H_
+#define PRINTF_H_
+
+#include <types.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef __GNUC__
+#define ATTR_PRINTF(one_based_format_index, first_arg) \
+    __attribute__((format(__printf__, (one_based_format_index), (first_arg))))
+#define ATTR_VPRINTF(one_based_format_index) ATTR_PRINTF((one_based_format_index), 0)
+#else
+#define ATTR_PRINTF((one_based_format_index), (first_arg))
+#define ATTR_VPRINTF(one_based_format_index)
+#endif
+
+#ifndef PRINTF_ALIAS_STANDARD_FUNCTION_NAMES
+#define PRINTF_ALIAS_STANDARD_FUNCTION_NAMES 0
+#endif
+
+#if PRINTF_ALIAS_STANDARD_FUNCTION_NAMES
+#define printf_ printf
+#define sprintf_ sprintf
+#define vsprintf_ vsprintf
+#define snprintf_ snprintf
+#define vsnprintf_ vsnprintf
+#define vprintf_ vprintf
+#endif
+
+// If you want to include this implementation file directly rather than
+// link against, this will let you control the functions' visibility,
+// e.g. make them static so as not to clash with other objects also
+// using them.
+#ifndef PRINTF_VISIBILITY
+#define PRINTF_VISIBILITY
+#endif
+
+    /**
+     * Prints/send a single character to some opaque output entity
+     *
+     * @note This function is not implemented by the library, only declared; you must provide an
+     * implementation if you wish to use the @ref printf / @ref vprintf function (and possibly
+     * for linking against the library, if your toolchain does not support discarding unused functions)
+     *
+     * @note The output could be as simple as a wrapper for the `write()` system call on a Unix-like
+     * system, or even libc's @ref putchar , for replicating actual functionality of libc's @ref printf
+     * function; but on an embedded system it may involve interaction with a special output device,
+     * like a UART, etc.
+     *
+     * @note in libc's @ref putchar, the parameter type is an int; this was intended to support the
+     * representation of either a proper character or EOF in a variable - but this is really not
+     * meaningful to pass into @ref putchar and is discouraged today. See further discussion in:
+     * @link https://stackoverflow.com/q/17452847/1593077
+     *
+     * @param c the single character to print
+     */
+    PRINTF_VISIBILITY
+    void putchar(char c);
+
+    /**
+     * An implementation of the C standard's printf/vprintf
+     *
+     * @note you must implement a @ref putchar_ function for using this function - it invokes @ref putchar_
+     * rather than directly performing any I/O (which insulates it from any dependence on the operating system
+     * and external libraries).
+     *
+     * @param format A string specifying the format of the output, with %-marked specifiers of how to interpret
+     * additional arguments.
+     * @param arg Additional arguments to the function, one for each %-specifier in @p format string
+     * @return The number of characters written into @p s, not counting the terminating null character
+     */
+    ///@{
+    PRINTF_VISIBILITY
+    int printf(const char *format, ...) ATTR_PRINTF(1, 2);
+    PRINTF_VISIBILITY
+    int vprintf(const char *format, va_list arg) ATTR_VPRINTF(1);
+    ///@}
+
+    /**
+     * An implementation of the C standard's sprintf/vsprintf
+     *
+     * @note For security considerations (the potential for exceeding the buffer bounds), please consider using
+     * the size-constrained variant, @ref snprintf / @ref vsnprintf , instead.
+     *
+     * @param s An array in which to store the formatted string. It must be large enough to fit the formatted
+     * output!
+     * @param format A string specifying the format of the output, with %-marked specifiers of how to interpret
+     * additional arguments.
+     * @param arg Additional arguments to the function, one for each specifier in @p format
+     * @return The number of characters written into @p s, not counting the terminating null character
+     */
+    ///@{
+    PRINTF_VISIBILITY
+    int sprintf(char *s, const char *format, ...) ATTR_PRINTF(2, 3);
+    PRINTF_VISIBILITY
+    int vsprintf(char *s, const char *format, va_list arg) ATTR_VPRINTF(2);
+    ///@}
+
+    /**
+     * An implementation of the C standard's snprintf/vsnprintf
+     *
+     * @param s An array in which to store the formatted string. It must be large enough to fit either the
+     * entire formatted output, or at least @p n characters. Alternatively, it can be NULL, in which case
+     * nothing will be printed, and only the number of characters which _could_ have been printed is
+     * tallied and returned.
+     * @param n The maximum number of characters to write to the array, including a terminating null character
+     * @param format A string specifying the format of the output, with %-marked specifiers of how to interpret
+     * additional arguments.
+     * @param arg Additional arguments to the function, one for each specifier in @p format
+     * @return The number of characters that COULD have been written into @p s, not counting the terminating
+     *         null character. A value equal or larger than @p n indicates truncation. Only when the returned value
+     *         is non-negative and less than @p n, the null-terminated string has been fully and successfully printed.
+     */
+    ///@{
+    PRINTF_VISIBILITY
+    int snprintf(char *s, size_t count, const char *format, ...) ATTR_PRINTF(3, 4);
+    PRINTF_VISIBILITY
+    int vsnprintf(char *s, size_t count, const char *format, va_list arg) ATTR_VPRINTF(3);
+    ///@}
+
+    /**
+     * printf/vprintf with user-specified output function
+     *
+     * An alternative to @ref printf_, in which the output function is specified dynamically
+     * (rather than @ref putchar_ being used)
+     *
+     * @param out An output function which takes one character and a type-erased additional parameters
+     * @param extra_arg The type-erased argument to pass to the output function @p out with each call
+     * @param format A string specifying the format of the output, with %-marked specifiers of how to interpret
+     * additional arguments.
+     * @param arg Additional arguments to the function, one for each specifier in @p format
+     * @return The number of characters for which the output f unction was invoked, not counting the terminating null character
+     *
+     */
+    PRINTF_VISIBILITY
+    int fctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, ...) ATTR_PRINTF(3, 4);
+    PRINTF_VISIBILITY
+    int vfctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, va_list arg) ATTR_VPRINTF(3);
+
+#if PRINTF_ALIAS_STANDARD_FUNCTION_NAMES
+#undef printf_
+#undef sprintf_
+#undef vsprintf_
+#undef snprintf_
+#undef vsnprintf_
+#undef vprintf_
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PRINTF_H_

libc/src/std/io.c

@@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <stdarg.h>
+
+FILE *stdin;
+FILE *stdout;
+FILE *stderr;
+
+int fclose(FILE *stream)
+{
+    return 0;
+}
+
+int fflush(FILE *stream)
+{
+    return 0;
+}
+
+FILE *fopen(const char *filename, const char *mode)
+{
+    return 0;
+}
+
+int fprintf(FILE *stream, const char *format, ...)
+{
+    return 0; // sprintf(char *s, const char *format, ...)
+}
+
+// int printf(const char *format, ...)
+// {
+//     return 0;
+// }
+
+size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+    return 0;
+}
+
+int fseek(FILE *stream, long offset, int whence)
+{
+    return 0;
+}
+
+long ftell(FILE *stream)
+{
+    return 0;
+}
+
+size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+    return 0;
+}
+
+void setbuf(FILE *stream, char *buf)
+{
+}
+
+// int vfprintf(FILE *stream, const char *format, va_list arg)
+// {
+//     return 0;
+// }
+
+int puts(const char *s)
+{
+    return 0;
+}
+
+int putchar(int c)
+{
+    return 0;
+}

libc/src/std/lib.c

@@ -0,0 +1,53 @@
+#include <stdlib.h>
+#include <stddef.h>
+
+#include "../mem/liballoc_1_1.h"
+
+void abort(void)
+{
+    while (1)
+        ;
+}
+
+int atexit(void (*function)(void))
+{
+    return 0;
+}
+
+void exit(int status)
+{
+    while (1)
+        ;
+}
+
+int atoi(const char *nptr)
+{
+    // uint64_t Length = strlen((char *)nptr);
+    uint64_t Length = 0;
+    if (nptr)
+        while (nptr[Length] != '\0')
+            ++Length;
+    uint64_t OutBuffer = 0;
+    uint64_t Power = 1;
+    for (uint64_t i = Length; i > 0; --i)
+    {
+        OutBuffer += (nptr[i - 1] - 48) * Power;
+        Power *= 10;
+    }
+    return OutBuffer;
+}
+
+char *getenv(const char *name)
+{
+    static char *env = "PATH=/bin";
+    return env;
+}
+
+void *malloc(size_t Size) { return PREFIX(malloc)(Size); }
+void *realloc(void *Address, size_t Size) { return PREFIX(realloc)(Address, Size); }
+void *calloc(size_t Count, size_t Size) { return PREFIX(calloc)(Count, Size); }
+void free(void *Address)
+{
+    PREFIX(free)
+    (Address);
+}