test

apps/system/init/Makefile

@@ -43,17 +43,14 @@ CFLAGS :=										\
 ifeq ($(OSARCH), amd64)
 
 CFLAGS += -fPIC -march=x86-64
-LDFLAGS += -Tarch/amd64/linker.ld
 
 else ifeq ($(OSARCH), i686)
 
 CFLAGS += -fPIC -march=i686
-LDFLAGS += -Tarch/i686/linker.ld
 
 else ifeq ($(OSARCH), aarch64)
 
 CFLAGS += -pipe -fPIC
-LDFLAGS += -Tarch/aarch64/linker.ld
 
 endif
 

apps/system/init/arch/amd64/linker.ld

@@ -1,34 +0,0 @@
-OUTPUT_FORMAT(elf64-x86-64)
-OUTPUT_ARCH(i386:x86-64)
-
-ENTRY(_start)
-
-SECTIONS
-{
-    .text :
-    {
-        *(.text .text.*)
-    }
-
-    .data :
-    {
-        *(.data .data.*)
-    }
-
-    .rodata :
-    {
-        *(.rodata .rodata.*)
-    }
-
-    .bss :
-    {
-        *(COMMON)
-        *(.bss .bss.*)
-    }
-
-    /DISCARD/ :
-    {
-        *(.eh_frame)
-        *(.note .note.*)
-    }
-}

apps/system/init/init.cpp

@@ -1,15 +1,81 @@
-#define UNUSED(x) (void)(x)
+#include "printf.h"
 
-extern "C" int main(int argc, char *argv[], char *envp[])
+#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
 {
-    UNUSED(argc);
+    unsigned long a_type;
-    UNUSED(argv);
+    union
-    UNUSED(envp);
+    {
+        unsigned long a_val;
+    } a_un;
+} Elf64_auxv_t;
 
-    unsigned long ret;
+static inline long syscall2(int sc, long arg1, long arg2)
-    asm volatile("syscall"
+{
-                 : "=a"(ret)
+    long ret;
-                 : "a"(1), "D"(1)
+    __asm__ __volatile__("syscall"
-                 : "rcx", "r11", "memory");
+                         : "=a"(ret)
+                         : "a"(sc), "D"(arg1), "S"(arg2)
+                         : "rcx", "r11", "memory");
     return ret;
 }
+
+extern "C" void putchar(char c) { syscall2(1, c, 0); }
+
+int main(int argc, char *argv[], char *envp[])
+{
+    printf_("Hello World!\n");
+    printf_("I have %d arguments\n", argc);
+    for (int i = 0; i < argc; i++)
+        printf_("argv[%d] = %s\n", i, argv[i]);
+    for (int i = 0; envp[i]; i++)
+        printf_("envp[%d] = %s\n", i, envp[i]);
+    Elf64_auxv_t *auxv;
+    while (*envp++ != NULL)
+        ;
+
+    int i = 0;
+    for (auxv = (Elf64_auxv_t *)envp; auxv->a_type != AT_NULL; auxv++)
+    {
+        printf_("%lu :%d\n", (auxv->a_type), i++);
+    }
+    return 0;
+}

apps/system/init/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/include/types.h

@@ -1,6 +1,210 @@
 #ifndef __FENNIX_LIBC_TYPES_H__
 #define __FENNIX_LIBC_TYPES_H__
 
+#ifdef __cplusplus
+#define EXTERNC extern "C"
+#define START_EXTERNC \
+    EXTERNC           \
+    {
+#define END_EXTERNC \
+    }
+#else
+#define EXTERNC
+#define START_EXTERNC
+#define END_EXTERNC
+#endif
+
+#ifdef __cplusplus
+#define NULL 0
+#else
 #define NULL ((void *)0)
+#define bool _Bool
+#endif
+
+#define asm __asm__
+#define asmv __asm__ volatile
+
+#define true 1
+#define false 0
+
+#ifdef __cplusplus
+#define foreach for
+#define in :
+#endif
+
+#define UNUSED(x) (void)(x)
+#define CONCAT(x, y) x##y
+
+#define toupper(c) ((c)-0x20 * (((c) >= 'a') && ((c) <= 'z')))
+#define tolower(c) ((c) + 0x20 * (((c) >= 'A') && ((c) <= 'Z')))
+
+#ifndef __va_list__
+typedef __builtin_va_list va_list;
+#endif
+
+#define va_start(v, l) __builtin_va_start(v, l)
+#define va_end(v) __builtin_va_end(v)
+#define va_arg(v, l) __builtin_va_arg(v, l)
+
+#define ALIGN_UP(x, align) ((__typeof__(x))(((uint64_t)(x) + ((align)-1)) & (~((align)-1))))
+#define ALIGN_DOWN(x, align) ((__typeof__(x))((x) & (~((align)-1))))
+
+#define offsetof(type, member) __builtin_offsetof(type, member)
+
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
+#define VPOKE(type, address) (*((volatile type *)(address)))
+#define POKE(type, address) (*((type *)(address)))
+
+#ifndef __cplusplus
+
+#ifdef __STDC__
+#ifdef __STDC_VERSION__
+#if (__STDC_VERSION__ >= 201710L)
+#define C_LANGUAGE_STANDARD 2018
+#elif (__STDC_VERSION__ >= 201112L)
+#define C_LANGUAGE_STANDARD 2011
+#elif (__STDC_VERSION__ >= 199901L)
+#define C_LANGUAGE_STANDARD 1999
+#elif (__STDC_VERSION__ >= 199409L)
+#define C_LANGUAGE_STANDARD 1995
+#endif
+#else
+#define C_LANGUAGE_STANDARD 1990
+#endif
+#else
+#define C_LANGUAGE_STANDARD 1972
+#endif
+
+#else
+
+#ifdef __STDC__
+#ifdef __cplusplus
+#if (__cplusplus >= 202100L)
+#define CPP_LANGUAGE_STANDARD 2023
+#elif (__cplusplus >= 202002L)
+#define CPP_LANGUAGE_STANDARD 2020
+#elif (__cplusplus >= 201703L)
+#define CPP_LANGUAGE_STANDARD 2017
+#elif (__cplusplus >= 201402L)
+#define CPP_LANGUAGE_STANDARD 2014
+#elif (__cplusplus >= 201103L)
+#define CPP_LANGUAGE_STANDARD 2011
+#elif (__cplusplus >= 199711L)
+#define CPP_LANGUAGE_STANDARD 1998
+#endif
+#else
+#define CPP_LANGUAGE_STANDARD __cplusplus
+#endif
+#else
+#define CPP_LANGUAGE_STANDARD __cplusplus
+#endif
+
+#endif // __cplusplus
+
+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;
+
+#define INT8_MAX __INT8_MAX__
+#define INT8_MIN (-INT8_MAX - 1)
+#define UINT8_MAX __UINT8_MAX__
+#define INT16_MAX __INT16_MAX__
+#define INT16_MIN (-INT16_MAX - 1)
+#define UINT16_MAX __UINT16_MAX__
+#define INT32_MAX __INT32_MAX__
+#define INT32_MIN (-INT32_MAX - 1)
+#define UINT32_MAX __UINT32_MAX__
+#define INT64_MAX __INT64_MAX__
+#define INT64_MIN (-INT64_MAX - 1)
+#define UINT64_MAX __UINT64_MAX__
+
+#define INT_LEAST8_MAX __INT_LEAST8_MAX__
+#define INT_LEAST8_MIN (-INT_LEAST8_MAX - 1)
+#define UINT_LEAST8_MAX __UINT_LEAST8_MAX__
+#define INT_LEAST16_MAX __INT_LEAST16_MAX__
+#define INT_LEAST16_MIN (-INT_LEAST16_MAX - 1)
+#define UINT_LEAST16_MAX __UINT_LEAST16_MAX__
+#define INT_LEAST32_MAX __INT_LEAST32_MAX__
+#define INT_LEAST32_MIN (-INT_LEAST32_MAX - 1)
+#define UINT_LEAST32_MAX __UINT_LEAST32_MAX__
+#define INT_LEAST64_MAX __INT_LEAST64_MAX__
+#define INT_LEAST64_MIN (-INT_LEAST64_MAX - 1)
+#define UINT_LEAST64_MAX __UINT_LEAST64_MAX__
+
+#define INT_FAST8_MAX __INT_FAST8_MAX__
+#define INT_FAST8_MIN (-INT_FAST8_MAX - 1)
+#define UINT_FAST8_MAX __UINT_FAST8_MAX__
+#define INT_FAST16_MAX __INT_FAST16_MAX__
+#define INT_FAST16_MIN (-INT_FAST16_MAX - 1)
+#define UINT_FAST16_MAX __UINT_FAST16_MAX__
+#define INT_FAST32_MAX __INT_FAST32_MAX__
+#define INT_FAST32_MIN (-INT_FAST32_MAX - 1)
+#define UINT_FAST32_MAX __UINT_FAST32_MAX__
+#define INT_FAST64_MAX __INT_FAST64_MAX__
+#define INT_FAST64_MIN (-INT_FAST64_MAX - 1)
+#define UINT_FAST64_MAX __UINT_FAST64_MAX__
+
+#define INTPTR_MAX __INTPTR_MAX__
+#define INTPTR_MIN (-INTPTR_MAX - 1)
+#define UINTPTR_MAX __UINTPTR_MAX__
+
+#define INTMAX_MAX __INTMAX_MAX__
+#define INTMAX_MIN (-INTMAX_MAX - 1)
+#define UINTMAX_MAX __UINTMAX_MAX__
+
+#define PTRDIFF_MAX __PTRDIFF_MAX__
+#define PTRDIFF_MIN (-PTRDIFF_MAX - 1)
+
+#define SIG_ATOMIC_MAX __SIG_ATOMIC_MAX__
+#define SIG_ATOMIC_MIN __SIG_ATOMIC_MIN__
+
+#define SIZE_MAX __SIZE_MAX__
+
+#define WCHAR_MAX __WCHAR_MAX__
+#define WCHAR_MIN __WCHAR_MIN__
+
+#define WINT_MAX __WINT_MAX__
+#define WINT_MIN __WINT_MIN__
+
+#define b4(x) ((x & 0x0F) << 4 | (x & 0xF0) >> 4)
+#define b8(x) ((x)&0xFF)
+#define b16(x) __builtin_bswap16(x)
+#define b32(x) __builtin_bswap32(x)
+#define b48(x) (((((x)&0x0000000000ff) << 40) | (((x)&0x00000000ff00) << 24) | (((x)&0x000000ff0000) << 8) | (((x)&0x0000ff000000) >> 8) | (((x)&0x00ff00000000) >> 24) | (((x)&0xff0000000000) >> 40)))
+#define b64(x) __builtin_bswap64(x)
 
 #endif // !__FENNIX_LIBC_TYPES_H__

libc/runtime/crt0.c

@@ -1,10 +1,16 @@
 int main(int argc, char *argv[], char *envp[]);
 
-int _start(void *Data)
+void _start()
 {
-    int mainret = main((int)0, (char **)0, (char **)0);
+    // TODO: Implement
-    while (1)
+    int *argc = 0;
-        ;
+    char **argv = 0;
-    return 0;
+    char **envp = 0;
+    int mainret = main((int)*argc, (char **)argv, (char **)envp);
+    __asm__ __volatile__("syscall"
+                         :
+                         : "a"(0), "D"(mainret)
+                         : "rcx", "r11", "memory");
+    return;
 }
 // C stuff

libc/runtime/crt1.c

@@ -1,10 +1,16 @@
 int main(int argc, char *argv[], char *envp[]);
 
-int _start(void *Data)
+void _start()
 {
-    int mainret = main((int)0, (char **)0, (char **)0);
+    // TODO: Implement
-    while (1)
+    int *argc = 0;
-        ;
+    char **argv = 0;
-    return 0;
+    char **envp = 0;
+    int mainret = main((int)*argc, (char **)argv, (char **)envp);
+    __asm__ __volatile__("syscall"
+                         :
+                         : "a"(0), "D"(mainret)
+                         : "rcx", "r11", "memory");
+    return;
 }
 // C++ stuff