x86 support!

Common/Std/linux-amd64.c

@@ -6,7 +6,6 @@
 
 #include "../std.h"
 #include <fcntl.h>
-#include <stdarg.h>
 #include <stdint.h>
 #include <sys/socket.h>
 #include <sys/un.h>
@@ -20,7 +19,7 @@ inline com_std_fd com_std_open(char *path, uint32_t flags) {
   long ret;
   __asm__ volatile("syscall"
                    : "=a"(ret)
-                   : "a"(2), "D"(path), "S"(mode)
+                   : "a"(2), "D"(path), "S"(mode), "d"(0)
                    : "rcx", "r11", "memory");
   if (ret <= 0) /* Mark NULL, removing error code */
     ret = 0;
@@ -90,4 +89,5 @@ inline void com_std_exit(uint32_t status) {
 
 inline void com_std_close(com_std_fd fd) {
   __asm__ volatile("syscall" : : "a"(3), "D"(fd) : "rcx", "r11", "memory");
+  /* TODO: At least assert for bad descriptor for debug? */
 }

Common/Std/linux-x86.c

@@ -0,0 +1,92 @@
+/*
+  AMD64 specific Linux std parts.
+*/
+
+#include "linux.c"
+
+#include "../std.h"
+#include <fcntl.h>
+#include <stdint.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+inline com_std_fd com_std_open(char *path, uint32_t flags) {
+  com_std_assert(flags != 0);
+  uint32_t mode = flags & COM_STD_OPEN_READ && flags & COM_STD_OPEN_WRITE
+                      ? O_RDWR
+                  : flags & COM_STD_OPEN_READ ? O_RDONLY
+                                              : O_WRONLY;
+  long ret;
+  __asm__ volatile("int $0x80"
+                   : "=a"(ret)
+                   : "a"(5), "b"(path), "c"(mode), "d"(0)
+                   : "memory", "cc");
+  if (ret <= 0) /* Mark NULL, removing error code */
+    ret = 0;
+  return (void *)ret;
+}
+
+inline bool com_std_write(com_std_fd fd, char const *data, uint32_t bytes) {
+  long ret;
+  __asm__ volatile("int $0x80"
+                   : "=a"(ret)
+                   : "a"(4), "b"(fd), "c"(data), "d"(bytes)
+                   : "memory", "cc");
+  return ret == bytes;
+}
+
+inline int32_t com_std_read(com_std_fd fd, char *data, uint32_t upto) {
+  long ret;
+  __asm__ volatile("int $0x80"
+                   : "=a"(ret)
+                   : "a"(3), "b"(fd), "c"(data), "d"(upto)
+                   : "memory", "cc");
+  return ret;
+}
+
+inline bool com_std_sfwd(com_std_fd fd, uint32_t bytes) {
+  long ret;
+  __asm__ volatile("int $0x80"
+                   : "=a"(ret)
+                   : "a"(19), "b"(fd), "c"(bytes), "d"(SEEK_CUR)
+                   : "memory", "cc");
+  return ret >= 0; /* TODO: Check whether offset is bytes offset exactly? */
+}
+
+inline com_std_fd com_std_socket(bool isnetwork) {
+  if (!isnetwork) {
+    int32_t sockfd;
+    __asm__ volatile("int $0x80"
+                     : "=a"(sockfd)
+                     : "a"(359), "b"(AF_UNIX), "c"(SOCK_STREAM), "d"(0)
+                     : "memory", "cc");
+    if (sockfd < 0)
+      sockfd = 0;
+    return (void *)(int64_t)sockfd;
+  } else
+    return NULL;
+}
+
+inline bool com_std_connect(com_std_fd fd, bool isnetwork, char *address) {
+  com_std_assert(address != NULL);
+  if (!isnetwork) {
+    struct sockaddr_un addr = {.sun_family = AF_UNIX};
+    __builtin_memcpy(&addr.sun_path, address, com_str_ext_len(address));
+    int32_t ret;
+    __asm__ volatile("int $0x80"
+                     : "=a"(ret)
+                     : "a"(362), "b"(fd), "c"(&addr), "d"(sizeof addr)
+                     : "memory", "cc");
+    return ret == 0;
+  } else
+    return NULL;
+}
+
+inline void com_std_exit(uint32_t status) {
+  __asm__ volatile("int $0x80" : : "a"(1), "b"(status) : "memory", "cc");
+  __builtin_unreachable();
+}
+
+inline void com_std_close(com_std_fd fd) {
+  __asm__ volatile("int $0x80" : : "a"(6), "b"(fd) : "memory", "cc");
+}