compiled newlib, need to hook up the system calls

rocklibc/src/rockos/syscall.c

@@ -0,0 +1,97 @@
+#include <stdint.h>
+#include <stddef.h>
+
+typedef int _PDCLIB_fd_t;
+
+static inline int32_t inline_syscall(uint32_t num, uint32_t arg1, uint32_t arg2, uint32_t arg3) {
+    int32_t ret;
+    asm volatile (
+        "int $0x80"
+        : "=a" (ret)
+        : "a" (num), "b" (arg1), "c" (arg2), "d" (arg3)
+        : "memory"
+    );
+    return ret;
+}
+
+void _PDCLIB_exit(int status) {
+    inline_syscall(1, (uint32_t)status, 0, 0);
+    while(1); // Halt if exit fails to yield
+}
+
+int _PDCLIB_read(_PDCLIB_fd_t fd, void *buf, size_t count) {
+    return inline_syscall(3, (uint32_t)fd, (uint32_t)buf, (uint32_t)count);
+}
+
+// 3. sys_write (eax = 4)
+int _PDCLIB_write(_PDCLIB_fd_t fd, const void *buf, size_t count) {
+    return inline_syscall(4, (uint32_t)fd, (uint32_t)buf, (uint32_t)count);
+}
+
+_PDCLIB_fd_t _PDCLIB_open(const char *filename, unsigned int mode) {
+    _PDCLIB_fd_t fd;
+    fd = inline_syscall(5, (uint32_t)filename, (uint32_t)mode, 0);
+    return fd;
+}
+
+int _PDCLIB_close(_PDCLIB_fd_t fd) {
+    return inline_syscall(6, (uint32_t)fd, 0, 0);
+}
+
+void * _PDCLIB_allocpages(size_t n) {
+    // n is the number of PAGES PDCLib wants (usually 4096 bytes per page)
+    size_t bytes_requested = n * 4096;
+    
+    // Call your sys_brk with 0 to find the current break address
+    uint32_t current_break = inline_syscall(12, 0, 0, 0);
+    
+    // Request the new break point
+    uint32_t new_break = current_break + bytes_requested;
+    uint32_t result = inline_syscall(12, new_break, 0, 0);
+    
+    if (result == 0) { 
+        return (void *)current_break; // Return the start of the newly allocated region
+    }
+    return NULL; // Allocation failed
+}
+
+int _PDCLIB_remove(const char *filename) { return -1; }
+int _PDCLIB_rename(const char *old, const char *new) { return -1; }
+long _PDCLIB_lseek(_PDCLIB_fd_t fd, long offset, int whence) { return -1; }
+
+int open(const char *pathname, int flags, ...) {
+    // Wrap to your internal _PDCLIB_open or inline_syscall directly
+    _PDCLIB_fd_t fd = _PDCLIB_open(pathname, (unsigned int)flags);
+    return fd;
+}
+
+int read(int fd, void *buf, size_t count) {
+    _PDCLIB_fd_t file_desc =  fd;
+    return _PDCLIB_read(file_desc, buf, count);
+}
+
+int write(int fd, const void *buf, size_t count) {
+    return _PDCLIB_write(fd, buf, count);
+}
+
+int close(int fd) {
+    _PDCLIB_fd_t file_desc = fd;
+    return _PDCLIB_close(file_desc);
+}
+
+void _exit(int status) {
+    _PDCLIB_exit(status);
+}
+
+void * sbrk(intptr_t increment) {
+    // If increment is 0, dlmalloc is querying the current boundary.
+    // For a simple implementation, let's look up memory by pages.
+    if (increment == 0) {
+         return _PDCLIB_allocpages(0); 
+    }
+    
+    // Convert bytes requested by sbrk into page increments (4KB blocks)
+    // You can also change your syscall wrapper to use regular byte increments
+    size_t pages_needed = ((size_t)increment + 4095) / 4096;
+    return _PDCLIB_allocpages(pages_needed);
+}