From 9f16b032d38613ca95e321e1d1e652c43129c68b Mon Sep 17 00:00:00 2001 From: Marvin Borner Date: Sat, 15 Aug 2020 17:42:36 +0200 Subject: Added libgui --- libc/Makefile | 36 ++++++++++++++ libc/conv.c | 144 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ libc/cpu.c | 75 ++++++++++++++++++++++++++++ libc/inc/arg.h | 11 +++++ libc/inc/assert.h | 14 ++++++ libc/inc/conv.h | 15 ++++++ libc/inc/cpu.h | 30 ++++++++++++ libc/inc/def.h | 28 +++++++++++ libc/inc/list.h | 25 ++++++++++ libc/inc/math.h | 10 ++++ libc/inc/mem.h | 27 ++++++++++ libc/inc/print.h | 14 ++++++ libc/inc/serial.h | 9 ++++ libc/inc/str.h | 17 +++++++ libc/inc/sys.h | 27 ++++++++++ libc/list.c | 74 ++++++++++++++++++++++++++++ libc/math.c | 15 ++++++ libc/mem.c | 35 +++++++++++++ libc/print.c | 104 +++++++++++++++++++++++++++++++++++++++ libc/serial.c | 34 +++++++++++++ libc/str.c | 98 +++++++++++++++++++++++++++++++++++++ libc/sys.c | 57 +++++++++++++++++++++ 22 files changed, 899 insertions(+) create mode 100644 libc/Makefile create mode 100644 libc/conv.c create mode 100644 libc/cpu.c create mode 100644 libc/inc/arg.h create mode 100644 libc/inc/assert.h create mode 100644 libc/inc/conv.h create mode 100644 libc/inc/cpu.h create mode 100644 libc/inc/def.h create mode 100644 libc/inc/list.h create mode 100644 libc/inc/math.h create mode 100644 libc/inc/mem.h create mode 100644 libc/inc/print.h create mode 100644 libc/inc/serial.h create mode 100644 libc/inc/str.h create mode 100644 libc/inc/sys.h create mode 100644 libc/list.c create mode 100644 libc/math.c create mode 100644 libc/mem.c create mode 100644 libc/print.c create mode 100644 libc/serial.c create mode 100644 libc/str.c create mode 100644 libc/sys.c (limited to 'libc') diff --git a/libc/Makefile b/libc/Makefile new file mode 100644 index 0000000..f4286ae --- /dev/null +++ b/libc/Makefile @@ -0,0 +1,36 @@ +# MIT License, Copyright (c) 2020 Marvin Borner + +# TODO: Remove serial and cpu from libc? +COBJS = str.o \ + mem.o \ + math.o \ + conv.o \ + print.o \ + serial.o \ + cpu.o \ + sys.o \ + list.o +CC = ../cross/opt/bin/i686-elf-gcc +LD = ../cross/opt/bin/i686-elf-ld +OC = ../cross/opt/bin/i686-elf-ar + +# Flags to make the binary smaller TODO: Remove after indirect pointer support! +CSFLAGS = -mpreferred-stack-boundary=2 -fno-asynchronous-unwind-tables -Os + +CFLAGS = $(CSFLAGS) -Wall -Wextra -nostdlib -nostdinc -ffreestanding -fno-builtin -mgeneral-regs-only -std=c99 -m32 -pedantic-errors -Iinc/ + +%.o: %.c + @$(CC) -c $(CFLAGS) $< -o $@ + +libc: CFLAGS += -Duserspace -fPIE +libc: $(COBJS) + @mkdir -p ../build/ + @$(AR) qc ../build/libc.a $+ + +libk: CFLAGS += -Dkernel +libk: $(COBJS) + @mkdir -p ../build/ + @$(AR) qc ../build/libk.a $+ + +clean: + @find . -name "*.o" -type f -delete diff --git a/libc/conv.c b/libc/conv.c new file mode 100644 index 0000000..3bde4ec --- /dev/null +++ b/libc/conv.c @@ -0,0 +1,144 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#include +#include +#include +#include + +static const char HTOA_TABLE[] = "0123456789ABCDEF"; +static const char ITOA_TABLE[] = "0123456789"; + +int atoi(char *str) +{ + u32 s_str = strlen(str); + if (!s_str) + return 0; + + u8 negative = 0; + if (str[0] == '-') + negative = 1; + + u32 i = 0; + if (negative) + i++; + + int ret = 0; + for (; i < s_str; i++) { + ret += (str[i] - '0') * pow(10, (int)((s_str - i) - 1)); + } + + if (negative) + ret *= -1; + return ret; +} + +char *htoa(u32 n) +{ + char *ret = (char *)malloc(10); + + int i = 0; + while (n) { + ret[i++] = HTOA_TABLE[n & 0xF]; + n >>= 4; + } + + if (!i) { + ret[0] = '0'; + i++; + } + + for (; i <= 9; i++) + ret[i] = 0; + + char *aux = strdup(ret); + free(ret); + ret = aux; + + strinv(ret); + return ret; +} + +int htoi(char *str) +{ + u32 s_str = strlen(str); + + u32 i = 0; + int ret = 0; + for (; i < s_str; i++) { + char c = str[i]; + int aux = 0; + if (c >= '0' && c <= '9') + aux = c - '0'; + else if (c >= 'A' && c <= 'F') + aux = (c - 'A') + 10; + + ret += aux * pow(16, (int)((s_str - i) - 1)); + } + + return ret; +} + +char *itoa(int n) +{ + if (!n) { + char *ret = (char *)malloc(2); + ret[0] = '0'; + ret[1] = 0; + return ret; + } + u8 negative = (u8)(n < 0); + if (negative) + n *= -1; + + int sz; + for (sz = 0; n % pow(10, sz) != n; sz++) { + } + + char *ret = (char *)malloc((u32)(sz + 1)); + + for (int i = 0; i < sz; i++) { + int digit = (n % pow(10, i + 1)) / pow(10, i); + ret[i] = ITOA_TABLE[digit]; + } + ret[sz] = 0; + + if (negative) { + char *aux = (char *)malloc((u32)(sz + 2)); + strcpy(aux, ret); + aux[sz] = '-'; + aux[sz + 1] = 0; + free(ret); + ret = aux; + } + + strinv(ret); + return ret; +} + +char *conv_base(int value, char *result, int base, int is_signed) +{ + if (base < 2 || base > 36) { + *result = '\0'; + return result; + } + + char *ptr = result, *ptr1 = result, tmp_char; + int tmp_value; + + do { + tmp_value = value; + value /= base; + *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz" + [35 + (tmp_value - value * base)]; + } while (value); + + if (is_signed && tmp_value < 0) + *ptr++ = '-'; + *ptr-- = '\0'; + while (ptr1 < ptr) { + tmp_char = *ptr; + *ptr-- = *ptr1; + *ptr1++ = tmp_char; + } + return result; +} diff --git a/libc/cpu.c b/libc/cpu.c new file mode 100644 index 0000000..5ed9de9 --- /dev/null +++ b/libc/cpu.c @@ -0,0 +1,75 @@ +// MIT License, Copyright (c) 2020 Marvin Borner +// This file is a wrapper around some CPU asm calls + +#include + +u8 inb(u16 port) +{ + u8 value; + __asm__ volatile("inb %1, %0" : "=a"(value) : "Nd"(port)); + return value; +} + +u16 inw(u16 port) +{ + u16 value; + __asm__ volatile("inw %1, %0" : "=a"(value) : "Nd"(port)); + return value; +} + +u32 inl(u16 port) +{ + u32 value; + __asm__ volatile("inl %1, %0" : "=a"(value) : "Nd"(port)); + return value; +} + +void insl(u16 port, void *addr, int n) +{ + __asm__ volatile("cld; rep insl" + : "=D"(addr), "=c"(n) + : "d"(port), "0"(addr), "1"(n) + : "memory", "cc"); +} + +void outb(u16 port, u8 data) +{ + __asm__ volatile("outb %0, %1" ::"a"(data), "Nd"(port)); +} + +void outw(u16 port, u16 data) +{ + __asm__ volatile("outw %0, %1" ::"a"(data), "Nd"(port)); +} + +void outl(u16 port, u32 data) +{ + __asm__ volatile("outl %0, %1" ::"a"(data), "Nd"(port)); +} + +void cli() +{ + __asm__ volatile("cli"); +} + +void sti() +{ + __asm__ volatile("sti"); +} + +void hlt() +{ + __asm__ volatile("hlt"); +} + +void idle() +{ + while (1) + hlt(); +} + +void loop() +{ + cli(); + idle(); +} diff --git a/libc/inc/arg.h b/libc/inc/arg.h new file mode 100644 index 0000000..73e592d --- /dev/null +++ b/libc/inc/arg.h @@ -0,0 +1,11 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#ifndef ARG_H +#define ARG_H + +typedef __builtin_va_list va_list; +#define va_start __builtin_va_start +#define va_end __builtin_va_end +#define va_arg __builtin_va_arg + +#endif diff --git a/libc/inc/assert.h b/libc/inc/assert.h new file mode 100644 index 0000000..91c4ccd --- /dev/null +++ b/libc/inc/assert.h @@ -0,0 +1,14 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#ifndef ASSERT_H +#define ASSERT_H + +#include + +#define assert(exp) \ + if (!(exp)) { \ + printf("%s:%d: %s: Assertion '%s' failed\n", __FILE__, __LINE__, __func__, #exp); \ + __asm__ volatile("cli\nhlt"); \ + } + +#endif diff --git a/libc/inc/conv.h b/libc/inc/conv.h new file mode 100644 index 0000000..d878deb --- /dev/null +++ b/libc/inc/conv.h @@ -0,0 +1,15 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#ifndef CONV_H +#define CONV_H + +#include + +int atoi(char *str); +char *htoa(u32 n); +int htoi(char *str); +char *itoa(int n); + +char *conv_base(int value, char *result, int base, int is_signed); + +#endif diff --git a/libc/inc/cpu.h b/libc/inc/cpu.h new file mode 100644 index 0000000..2d367cb --- /dev/null +++ b/libc/inc/cpu.h @@ -0,0 +1,30 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#ifndef CPU_H +#define CPU_H + +#include + +u8 inb(u16 port); +u16 inw(u16 port); +u32 inl(u16 port); +void insl(u16 port, void *addr, int n); + +void outb(u16 port, u8 data); +void outw(u16 port, u16 data); +void outl(u16 port, u32 data); +void cli(); +void sti(); +void hlt(); +void idle(); +void loop(); + +static inline void spinlock(int *ptr) +{ + int prev; + do + __asm__ volatile("lock xchgl %0,%1" : "=a"(prev) : "m"(*ptr), "a"(1)); + while (prev); +} + +#endif diff --git a/libc/inc/def.h b/libc/inc/def.h new file mode 100644 index 0000000..42939a0 --- /dev/null +++ b/libc/inc/def.h @@ -0,0 +1,28 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#ifndef DEF_H +#define DEF_H + +/** + * Types + */ + +typedef signed char s8; +typedef unsigned char u8; + +typedef signed short s16; +typedef unsigned short u16; + +typedef signed long s32; +typedef unsigned long u32; + +typedef signed long long s64; +typedef unsigned long long u64; + +/** + * Macros + */ + +#define NULL ((void *)0) + +#endif diff --git a/libc/inc/list.h b/libc/inc/list.h new file mode 100644 index 0000000..5deaf59 --- /dev/null +++ b/libc/inc/list.h @@ -0,0 +1,25 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#ifndef LIST_H +#define LIST_H + +#include + +struct list { + struct node *head; +}; + +struct node { + void *data; + int nonce; + struct node *next; + struct node *prev; +}; + +struct list *list_new(); +/* struct node *list_new_node(); */ // TODO: Make node-specific things static/private? +/* void list_add_node(struct list *list, struct node *node); */ +void list_add(struct list *list, void *data); +void list_remove(struct list *list, struct node *node); + +#endif diff --git a/libc/inc/math.h b/libc/inc/math.h new file mode 100644 index 0000000..268e3e7 --- /dev/null +++ b/libc/inc/math.h @@ -0,0 +1,10 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#ifndef MATH_H +#define MATH_H + +#include + +int pow(int base, int exp); + +#endif diff --git a/libc/inc/mem.h b/libc/inc/mem.h new file mode 100644 index 0000000..0030b3d --- /dev/null +++ b/libc/inc/mem.h @@ -0,0 +1,27 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#ifndef MEM_H +#define MEM_H + +#include + +// Huh +#ifdef kernel +#define malloc(n) (void *)((HEAP += n) - n) // TODO: Implement real/better malloc/free +#define free(ptr) +#elif defined(userspace) +#include +#define malloc(n) (void *)sys1(SYS_MALLOC, n) +#define free(ptr) (void)(sys1(SYS_FREE, (int)ptr)) +#else +#error "No lib target specified. Please use -Dkernel or -Duserspace" +#endif + +u32 HEAP; +u32 HEAP_START; + +void *memcpy(void *dst, const void *src, u32 n); +void *memset(void *dst, int c, u32 n); +int memcmp(const void *s1, const void *s2, u32 n); + +#endif diff --git a/libc/inc/print.h b/libc/inc/print.h new file mode 100644 index 0000000..04668b2 --- /dev/null +++ b/libc/inc/print.h @@ -0,0 +1,14 @@ +// MIT License, Copyright (c) 2020 Marvin Borner +// I may (re)move this in the future // TODO + +#ifndef PRINT_H +#define PRINT_H + +#include "arg.h" + +int printf(const char *format, ...); +int vprintf(const char *format, va_list ap); +int vsprintf(char *str, const char *format, va_list ap); +int print(const char *str); + +#endif diff --git a/libc/inc/serial.h b/libc/inc/serial.h new file mode 100644 index 0000000..6511952 --- /dev/null +++ b/libc/inc/serial.h @@ -0,0 +1,9 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#ifndef SERIAL_H +#define SERIAL_H + +void serial_install(); +void serial_print(const char *data); + +#endif diff --git a/libc/inc/str.h b/libc/inc/str.h new file mode 100644 index 0000000..65774e7 --- /dev/null +++ b/libc/inc/str.h @@ -0,0 +1,17 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#ifndef STR_H +#define STR_H + +#include + +u32 strlen(const char *s); +char *strcpy(char *dst, const char *src); +char *strchr(const char *s, int c); +char *strcat(char *dst, const char *src); +int strcmp(const char *s1, const char *s2); +int strncmp(const char *s1, const char *s2, u32 n); +char *strinv(char *s); +char *strdup(const char *s); + +#endif diff --git a/libc/inc/sys.h b/libc/inc/sys.h new file mode 100644 index 0000000..16d3c4f --- /dev/null +++ b/libc/inc/sys.h @@ -0,0 +1,27 @@ +// MIT License, Copyright (c) 2020 Marvin Borner +// Syscall implementation + +#ifndef SYS_H +#define SYS_H + +enum sys { SYS_LOOP, SYS_MALLOC, SYS_FREE, SYS_EXEC, SYS_EXIT }; + +int sys0(enum sys num); +int sys1(enum sys num, int d1); +int sys2(enum sys num, int d1, int d2); +int sys3(enum sys num, int d1, int d2, int d3); +int sys4(enum sys num, int d1, int d2, int d3, int d4); +int sys5(enum sys num, int d1, int d2, int d3, int d4, int d5); + +/** + * Wrappers + */ + +#define loop() sys0(SYS_LOOP) +#define exec(path) sys1(SYS_EXEC, (int)path) +#define exit() \ + sys0(SYS_EXIT); \ + while (1) { \ + } + +#endif diff --git a/libc/list.c b/libc/list.c new file mode 100644 index 0000000..c36d6e1 --- /dev/null +++ b/libc/list.c @@ -0,0 +1,74 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#include +#include +#include + +static int nonce = 0; + +struct list *list_new() +{ + struct list *list = malloc(sizeof(*list)); + list->head = NULL; + return list; +} + +struct node *list_new_node() +{ + struct node *node = malloc(sizeof(*node)); + node->data = NULL; + node->prev = NULL; + node->next = NULL; + node->nonce = nonce++; + return node; +} + +void list_add_node(struct list *list, struct node *node) +{ + if (list == NULL) + return; + + if (list->head == NULL) { + list->head = node; + return; + } + + struct node *iterator = list->head; + while (iterator != NULL) { + if (iterator->next == NULL) { + iterator->next = node; + node->prev = iterator; + break; + } + iterator = iterator->next; + } +} + +void list_add(struct list *list, void *data) +{ + struct node *node = list_new_node(); + node->data = data; + list_add_node(list, node); +} + +// Maybe list_remove_node? +void list_remove(struct list *list, struct node *node) +{ + if (list == NULL || list->head == NULL) + return; + + if (list->head == node) { + list->head = list->head->next; + return; + } + + struct node *iterator = list->head->next; + while (iterator != node) { + iterator = iterator->next; + if (iterator == NULL) + return; + } + + iterator->prev->next = iterator->next; + iterator->next->prev = iterator->prev; +} diff --git a/libc/math.c b/libc/math.c new file mode 100644 index 0000000..9cd9cea --- /dev/null +++ b/libc/math.c @@ -0,0 +1,15 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +int pow(int base, int exp) +{ + if (exp < 0) + return 0; + + if (!exp) + return 1; + + int ret = base; + for (int i = 1; i < exp; i++) + ret *= base; + return ret; +} diff --git a/libc/mem.c b/libc/mem.c new file mode 100644 index 0000000..58c337b --- /dev/null +++ b/libc/mem.c @@ -0,0 +1,35 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#include +#include +#include + +void *memcpy(void *dst, const void *src, u32 n) +{ + const char *sp = (const char *)src; + char *dp = (char *)dst; + for (; n != 0; n--) + *dp++ = *sp++; + return dst; +} + +void *memset(void *dst, char val, u32 n) +{ + char *temp = (char *)dst; + for (; n != 0; n--) + *temp++ = val; + return dst; +} + +int memcmp(const void *s1, const void *s2, u32 n) +{ + const u8 *a = (const u8 *)s1; + const u8 *b = (const u8 *)s2; + for (u32 i = 0; i < n; i++) { + if (a[i] < b[i]) + return -1; + else if (b[i] < a[i]) + return 1; + } + return 0; +} diff --git a/libc/print.c b/libc/print.c new file mode 100644 index 0000000..84c4975 --- /dev/null +++ b/libc/print.c @@ -0,0 +1,104 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#include +#include +#include +#include +#include +#include + +static void append(char *dest, char *src, int index) +{ + for (u32 i = index; i < strlen(src) + index; i++) + dest[i] = src[i - index]; + dest[index + strlen(src)] = 0; +} + +int vsprintf(char *str, const char *format, va_list ap) +{ + u8 ready_to_format = 0; + + int i = 0; + char buf = 0; + char format_buffer[20] = "\0"; + + for (; *format; format++) { + if (ready_to_format) { + ready_to_format = 0; + + if (*format == '%') { + str[i] = '%'; + continue; + } + + buf = *format; + + // TODO: Improve this repetitive code + if (buf == 's') { + char *string = va_arg(ap, char *); + append(str, string, i); + i = strlen(str); + } else if (buf == 'x') { + conv_base(va_arg(ap, u32), format_buffer, 16, 0); + append(str, format_buffer, i); + i = strlen(str); + } else if (buf == 'd' || buf == 'i') { + conv_base(va_arg(ap, s32), format_buffer, 10, 1); + append(str, format_buffer, i); + i = strlen(str); + } else if (buf == 'u') { + conv_base(va_arg(ap, u32), format_buffer, 10, 0); + append(str, format_buffer, i); + i = strlen(str); + } else if (buf == 'o') { + conv_base(va_arg(ap, u32), format_buffer, 8, 0); + append(str, format_buffer, i); + i = strlen(str); + } else if (buf == 'b') { + conv_base(va_arg(ap, u32), format_buffer, 2, 0); + append(str, format_buffer, i); + i = strlen(str); + } else if (buf == 'c') { + str[i] = (char)va_arg(ap, int); + i++; + } + } else { + if (*format == '%') + ready_to_format = 1; + else { + str[i] = *format; + i++; + } + } + + format_buffer[0] = '\0'; + } + + return strlen(str); +} + +int vprintf(const char *format, va_list ap) +{ + char buf[1024]; + memset(buf, 0, 1024); + int len = vsprintf(buf, format, ap); + serial_print(buf); // TODO: Remove temporary serial print + return len; +} + +// TODO: Fix printf for *very* large strings (serial works) +int printf(const char *format, ...) +{ + va_list ap; + va_start(ap, format); + int len = vprintf(format, ap); + va_end(ap); + + return len; +} + +int print(const char *str) +{ + serial_print(str); + return strlen(str); +} diff --git a/libc/serial.c b/libc/serial.c new file mode 100644 index 0000000..28de140 --- /dev/null +++ b/libc/serial.c @@ -0,0 +1,34 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#include +#include +#include + +void serial_install() +{ + outb(0x3f8 + 1, 0x00); + outb(0x3f8 + 3, 0x80); + outb(0x3f8 + 0, 0x03); + outb(0x3f8 + 1, 0x00); + outb(0x3f8 + 3, 0x03); + outb(0x3f8 + 2, 0xC7); + outb(0x3f8 + 4, 0x0B); +} + +int is_transmit_empty() +{ + return inb(0x3f8 + 5) & 0x20; +} + +void serial_put(char ch) +{ + while (is_transmit_empty() == 0) + ; + outb(0x3f8, (u8)ch); +} + +void serial_print(const char *data) +{ + for (u32 i = 0; i < strlen(data); i++) + serial_put(data[i]); +} diff --git a/libc/str.c b/libc/str.c new file mode 100644 index 0000000..d1ee325 --- /dev/null +++ b/libc/str.c @@ -0,0 +1,98 @@ +// MIT License, Copyright (c) 2020 Marvin Borner + +#include +#include + +u32 strlen(const char *s) +{ + const char *ss = s; + while (*ss) + ss++; + return ss - s; +} + +char *strcpy(char *dst, const char *src) +{ + char *q = dst; + const char *p = src; + char ch; + + do { + *q++ = ch = *p++; + } while (ch); + + return dst; +} + +int strcmp(const char *s1, const char *s2) +{ + const u8 *c1 = (const u8 *)s1; + const u8 *c2 = (const u8 *)s2; + u8 ch; + int d = 0; + + while (1) { + d = (int)(ch = *c1++) - (int)*c2++; + if (d || !ch) + break; + } + + return d; +} + +int strncmp(const char *s1, const char *s2, u32 n) +{ + const u8 *c1 = (const u8 *)s1; + const u8 *c2 = (const u8 *)s2; + u8 ch; + int d = 0; + + while (n--) { + d = (int)(ch = *c1++) - (int)*c2++; + if (d || !ch) + break; + } + + return d; +} + +char *strchr(const char *s, int c) +{ + while (*s != (char)c) { + if (!*s) + return NULL; + s++; + } + + return (char *)s; +} + +char *strcat(char *dst, const char *src) +{ + strcpy(strchr(dst, '\0'), src); + return dst; +} + +char *strinv(char *s) +{ + u32 s_str = strlen(s); + + int iterations = (int)s_str / 2; + for (int i = 0; i < iterations; i++) { + char aux = s[i]; + s[i] = s[(s_str - i) - 1]; + s[(s_str - i) - 1] = aux; + } + return s; +} + +char *strdup(const char *s) +{ + int l = strlen(s) + 1; + char *d = malloc(l); + + if (d) + memcpy(d, s, l); + + return d; +} diff --git a/libc/sys.c b/libc/sys.c new file mode 100644 index 0000000..d676445 --- /dev/null +++ b/libc/sys.c @@ -0,0 +1,57 @@ +// MIT License, Copyright (c) 2020 Marvin Borner +// Syscall implementation + +#include + +/** + * Definitions + */ + +int sys0(enum sys num) +{ + int a; + __asm__ volatile("int $0x80" : "=a"(a) : "0"(num)); + return a; +} + +int sys1(enum sys num, int d1) +{ + int a; + __asm__ volatile("int $0x80" : "=a"(a) : "0"(num), "b"((int)d1)); + return a; +} + +int sys2(enum sys num, int d1, int d2) +{ + int a; + __asm__ volatile("int $0x80" : "=a"(a) : "0"(num), "b"((int)d1), "c"((int)d2)); + return a; +} + +int sys3(enum sys num, int d1, int d2, int d3) +{ + int a; + __asm__ volatile("int $0x80" + : "=a"(a) + : "0"(num), "b"((int)d1), "c"((int)d2), "d"((int)d3)); + return a; +} + +int sys4(enum sys num, int d1, int d2, int d3, int d4) +{ + int a; + __asm__ volatile("int $0x80" + : "=a"(a) + : "0"(num), "b"((int)d1), "c"((int)d2), "d"((int)d3), "S"((int)d4)); + return a; +} + +int sys5(enum sys num, int d1, int d2, int d3, int d4, int d5) +{ + int a; + __asm__ volatile("int $0x80" + : "=a"(a) + : "0"(num), "b"((int)d1), "c"((int)d2), "d"((int)d3), "S"((int)d4), + "D"((int)d5)); + return a; +} -- cgit v1.2.3