tests/invader/include/arch/riscv/csr.h

+// See LICENSE for license details.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int* csr_enum_array();
+const char** csr_name_array();
+long read_csr_enum(int csrenum);
+void write_csr_enum(int csrenum, long value);
+
+enum {
+    csr_none,
+    csr_fflags,
+    csr_frm,
+    csr_fcsr,
+    csr_mcycle,
+    csr_minstret,
+    csr_mcycleh,
+    csr_minstreth,
+    csr_cycle,
+    csr_time,
+    csr_instret,
+    csr_cycleh,
+    csr_timeh,
+    csr_instreth,
+    csr_mvendorid,
+    csr_marchid,
+    csr_mimpid,
+    csr_mhartid,
+    csr_mstatus,
+    csr_misa,
+    csr_medeleg,
+    csr_mideleg,
+    csr_mie,
+    csr_mtvec,
+    csr_mcounteren,
+    csr_mscratch,
+    csr_mepc,
+    csr_mcause,
+    csr_mtval,
+    csr_mip,
+    csr_sstatus,
+    csr_sedeleg,
+    csr_sideleg,
+    csr_sie,
+    csr_stvec,
+    csr_scounteren,
+    csr_sscratch,
+    csr_sepc,
+    csr_scause,
+    csr_stval,
+    csr_sip,
+    csr_satp,
+    csr_pmpcfg0,
+    csr_pmpcfg1,
+    csr_pmpcfg2,
+    csr_pmpcfg3,
+    csr_pmpaddr0,
+    csr_pmpaddr1,
+    csr_pmpaddr2,
+    csr_pmpaddr3,
+    csr_pmpaddr4,
+    csr_pmpaddr5,
+    csr_pmpaddr6,
+    csr_pmpaddr7,
+    csr_pmpaddr8,
+    csr_pmpaddr9,
+    csr_pmpaddr10,
+    csr_pmpaddr11,
+    csr_pmpaddr12,
+    csr_pmpaddr13,
+    csr_pmpaddr14,
+    csr_pmpaddr15
+};
+
+#ifdef __cplusplus
+}
+#endif

tests/invader/include/arch/riscv/encoding.h

+// See LICENSE for license details.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MSTATUS_UIE         0x00000001
+#define MSTATUS_SIE         0x00000002
+#define MSTATUS_HIE         0x00000004
+#define MSTATUS_MIE         0x00000008
+#define MSTATUS_UPIE        0x00000010
+#define MSTATUS_SPIE        0x00000020
+#define MSTATUS_HPIE        0x00000040
+#define MSTATUS_MPIE        0x00000080
+#define MSTATUS_SPP         0x00000100
+#define MSTATUS_HPP         0x00000600
+#define MSTATUS_MPP         0x00001800
+#define MSTATUS_FS          0x00006000
+#define MSTATUS_XS          0x00018000
+#define MSTATUS_MPRV        0x00020000
+#define MSTATUS_SUM         0x00040000
+#define MSTATUS_MXR         0x00080000
+#define MSTATUS_TVM         0x00100000
+#define MSTATUS_TW          0x00200000
+#define MSTATUS_TSR         0x00400000
+#define MSTATUS32_SD        0x80000000
+#define MSTATUS64_SD        0x8000000000000000
+
+#define SSTATUS_UIE         0x00000001
+#define SSTATUS_SIE         0x00000002
+#define SSTATUS_UPIE        0x00000010
+#define SSTATUS_SPIE        0x00000020
+#define SSTATUS_SPP         0x00000100
+#define SSTATUS_FS          0x00006000
+#define SSTATUS_XS          0x00018000
+#define SSTATUS_SUM         0x00040000
+#define SSTATUS_MXR         0x00080000
+#define SSTATUS32_SD        0x80000000
+#define SSTATUS64_SD        0x8000000000000000
+
+#define DCSR_XDEBUGVER      (3U<<30)
+#define DCSR_NDRESET        (1<<29)
+#define DCSR_FULLRESET      (1<<28)
+#define DCSR_EBREAKM        (1<<15)
+#define DCSR_EBREAKH        (1<<14)
+#define DCSR_EBREAKS        (1<<13)
+#define DCSR_EBREAKU        (1<<12)
+#define DCSR_STOPCYCLE      (1<<10)
+#define DCSR_STOPTIME       (1<<9)
+#define DCSR_CAUSE          (7<<6)
+#define DCSR_DEBUGINT       (1<<5)
+#define DCSR_HALT           (1<<3)
+#define DCSR_STEP           (1<<2)
+#define DCSR_PRV            (3<<0)
+
+#define DCSR_CAUSE_NONE     0
+#define DCSR_CAUSE_SWBP     1
+#define DCSR_CAUSE_HWBP     2
+#define DCSR_CAUSE_DEBUGINT 3
+#define DCSR_CAUSE_STEP     4
+#define DCSR_CAUSE_HALT     5
+
+#define MCONTROL_TYPE(xlen)    (0xfULL<<((xlen)-4))
+#define MCONTROL_DMODE(xlen)   (1ULL<<((xlen)-5))
+#define MCONTROL_MASKMAX(xlen) (0x3fULL<<((xlen)-11))
+
+#define MCONTROL_SELECT     (1<<19)
+#define MCONTROL_TIMING     (1<<18)
+#define MCONTROL_ACTION     (0x3f<<12)
+#define MCONTROL_CHAIN      (1<<11)
+#define MCONTROL_MATCH      (0xf<<7)
+#define MCONTROL_M          (1<<6)
+#define MCONTROL_H          (1<<5)
+#define MCONTROL_S          (1<<4)
+#define MCONTROL_U          (1<<3)
+#define MCONTROL_EXECUTE    (1<<2)
+#define MCONTROL_STORE      (1<<1)
+#define MCONTROL_LOAD       (1<<0)
+
+#define MCONTROL_TYPE_NONE      0
+#define MCONTROL_TYPE_MATCH     2
+
+#define MCONTROL_ACTION_DEBUG_EXCEPTION   0
+#define MCONTROL_ACTION_DEBUG_MODE        1
+#define MCONTROL_ACTION_TRACE_START       2
+#define MCONTROL_ACTION_TRACE_STOP        3
+#define MCONTROL_ACTION_TRACE_EMIT        4
+
+#define MCONTROL_MATCH_EQUAL     0
+#define MCONTROL_MATCH_NAPOT     1
+#define MCONTROL_MATCH_GE        2
+#define MCONTROL_MATCH_LT        3
+#define MCONTROL_MATCH_MASK_LOW  4
+#define MCONTROL_MATCH_MASK_HIGH 5
+
+#define MIP_SSIP            (1 << IRQ_S_SOFT)
+#define MIP_HSIP            (1 << IRQ_H_SOFT)
+#define MIP_MSIP            (1 << IRQ_M_SOFT)
+#define MIP_STIP            (1 << IRQ_S_TIMER)
+#define MIP_HTIP            (1 << IRQ_H_TIMER)
+#define MIP_MTIP            (1 << IRQ_M_TIMER)
+#define MIP_SEIP            (1 << IRQ_S_EXT)
+#define MIP_HEIP            (1 << IRQ_H_EXT)
+#define MIP_MEIP            (1 << IRQ_M_EXT)
+
+#define SIP_SSIP MIP_SSIP
+#define SIP_STIP MIP_STIP
+
+#define PRV_U 0
+#define PRV_S 1
+#define PRV_H 2
+#define PRV_M 3
+
+#define SPTBR32_MODE 0x80000000
+#define SPTBR32_ASID 0x7FC00000
+#define SPTBR32_PPN  0x003FFFFF
+#define SPTBR64_MODE 0xF000000000000000
+#define SPTBR64_ASID 0x0FFFF00000000000
+#define SPTBR64_PPN  0x00000FFFFFFFFFFF
+
+#define SPTBR_MODE_OFF  0
+#define SPTBR_MODE_SV32 1
+#define SPTBR_MODE_SV39 8
+#define SPTBR_MODE_SV48 9
+#define SPTBR_MODE_SV57 10
+#define SPTBR_MODE_SV64 11
+
+#define PMP_R     0x01
+#define PMP_W     0x02
+#define PMP_X     0x04
+#define PMP_A     0x18
+#define PMP_L     0x80
+#define PMP_SHIFT     2
+#define PMPCFG_COUNT  4
+#define PMPADDR_COUNT 16
+
+#define PMP_OFF   0x00
+#define PMP_TOR   0x08
+#define PMP_NA4   0x10
+#define PMP_NAPOT 0x18
+
+#define IRQ_S_SOFT   1
+#define IRQ_H_SOFT   2
+#define IRQ_M_SOFT   3
+#define IRQ_S_TIMER  5
+#define IRQ_H_TIMER  6
+#define IRQ_M_TIMER  7
+#define IRQ_S_EXT    9
+#define IRQ_H_EXT    10
+#define IRQ_M_EXT    11
+#define IRQ_COP      12
+#define IRQ_HOST     13
+
+#define DEFAULT_RSTVEC     0x00001000
+#define CLINT_BASE         0x02000000
+#define CLINT_SIZE         0x000c0000
+#define EXT_IO_BASE        0x40000000
+#define DRAM_BASE          0x80000000
+
+// page table entry (PTE) fields
+#define PTE_V     0x001 // Valid
+#define PTE_R     0x002 // Read
+#define PTE_W     0x004 // Write
+#define PTE_X     0x008 // Execute
+#define PTE_U     0x010 // User
+#define PTE_G     0x020 // Global
+#define PTE_A     0x040 // Accessed
+#define PTE_D     0x080 // Dirty
+#define PTE_SOFT  0x300 // Reserved for Software
+
+#define PTE_PPN_SHIFT 10
+
+#define PTE_TABLE(PTE) (((PTE) & (PTE_V | PTE_R | PTE_W | PTE_X)) == PTE_V)
+
+#ifdef __riscv
+
+#if __riscv_xlen == 64
+# define MSTATUS_SD MSTATUS64_SD
+# define SSTATUS_SD SSTATUS64_SD
+# define RISCV_PGLEVEL_BITS 9
+# define SPTBR_MODE SPTBR64_MODE
+#else
+# define MSTATUS_SD MSTATUS32_SD
+# define SSTATUS_SD SSTATUS32_SD
+# define RISCV_PGLEVEL_BITS 10
+# define SPTBR_MODE SPTBR32_MODE
+#endif
+#define RISCV_PGSHIFT 12
+#define RISCV_PGSIZE (1 << RISCV_PGSHIFT)
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif

tests/invader/include/arch/riscv/machine.h

+// See LICENSE for license details.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stddef.h>
+
+void arch_setup();
+void exit(int status) __attribute__((noreturn));
+
+#define die(str, ...) ({ \
+  printf("%s:%d: " str "\n", __FILE__, __LINE__, ##__VA_ARGS__); exit(-1); })
+
+#define assert(x) ({ if (!(x)) die("assertion failed: %s", #x); })
+
+#define read_const_csr(reg) ({ unsigned long __tmp; \
+  asm ("csrr %0, " #reg : "=r"(__tmp)); __tmp; })
+
+#define read_csr(reg) ({ unsigned long __tmp; \
+  asm volatile ("csrr %0, " #reg : "=r"(__tmp)); __tmp; })
+
+#define write_csr(reg, val) ({ \
+  asm volatile ("csrw " #reg ", %0" :: "rK"(val)); })
+
+#define swap_csr(reg, val) ({ unsigned long __tmp; \
+  asm volatile ("csrrw %0, " #reg ", %1" : "=r"(__tmp) : "rK"(val)); __tmp; })
+
+#define set_csr(reg, bit) ({ unsigned long __tmp; \
+  asm volatile ("csrrs %0, " #reg ", %1" : "=r"(__tmp) : "rK"(bit)); __tmp; })
+
+#define clear_csr(reg, bit) ({ unsigned long __tmp; \
+  asm volatile ("csrrc %0, " #reg ", %1" : "=r"(__tmp) : "rK"(bit)); __tmp; })
+
+static inline uintptr_t get_field(uintptr_t reg, uintptr_t mask)
+{
+    return ((reg & mask) / (mask & ~(mask << 1)));
+}
+
+static inline uintptr_t set_field(uintptr_t reg, uintptr_t mask, uintptr_t val)
+{
+    return ((reg & ~mask) | ((val * (mask & ~(mask << 1))) & mask));
+}
+
+static inline unsigned long rdtime() { return read_csr(time); }
+static inline unsigned long rdcycle() { return read_csr(cycle); }
+static inline unsigned long rdinstret() { return read_csr(instret); }
+static inline int64_t misa() { return read_const_csr(misa); }
+static inline int has_ext(char ext) { return misa() & (1 << (ext - 'a')); }
+static inline int xlen() { return misa() < 0 ? 64 : 32; }
+static inline void wfi() { asm volatile ("wfi" ::: "memory"); }
+
+__attribute__((noreturn)) static inline void mret()
+{
+    asm volatile ("mret");
+    __builtin_unreachable();
+}
+
+
+/*
+ * Memory
+ *
+ * TODO - improve this API to return a list of memory segments
+ */
+
+typedef struct memory_info
+{
+    uintptr_t start;
+    uintptr_t end;
+} memory_info_t;
+
+
+/*
+ * memory_probe - return memory_info
+ */
+memory_info_t memory_probe();
+
+/*
+ * memory_probe_range - probe a memory address range
+ */
+uintptr_t memory_probe_range(uintptr_t start, uintptr_t end);
+
+
+/*
+ * Physical Memory Protection
+ *
+ * PMP is optional but if implememented, enforcement must be enabled by
+ * default, if no PMP entries are set. This means loads, stores or fetches
+ * from any mode besides M mode, will fail unless explicitly allowed.
+ * PMP must be configured irregardless of whether it is implemented.
+ */
+
+typedef struct pmp_info
+{
+    int width;
+    int granularity;
+    int count;
+} pmp_info_t;
+
+/*
+ * pmp_probe - return pmp_info
+ */
+pmp_info_t pmp_probe();
+
+/*
+ * pmp_entry_granularity - return PMP entry width (physical memory width)
+ */
+int pmp_entry_width();
+
+/*
+ * pmp_entry_granularity - return PMP entry granularity (smallest entry size)
+ */
+int pmp_entry_granularity();
+
+/*
+ * pmp_entry_count - return number of PMP entries
+ */
+int pmp_entry_count();
+
+/*
+ * pmp_clear_all - set PMP to disallow mode != PRV_M physical memory accesses
+ */
+void pmp_clear_all();
+
+/*
+ * pmp_allow_all - set PMP to allow mode != PRV_M physical memory accesses
+ */
+void pmp_allow_all();
+
+/*
+ * pmp_entry_set - set one PMP entry
+ *
+ * - n    : pmp entry number
+ * - prot : protection (PMP_R | PMP_W | PMP_X)
+ * - addr : start address
+ * - len  : power of two length
+ */
+int pmp_entry_set(unsigned n, uint8_t prot, uint64_t addr, uint64_t len);
+
+
+/*
+ * Privileged modes
+ */
+
+/*
+ * mode_set_and_jump
+ *
+ * Set mstatus.mpp, sets mepc to passed function pointer and then issues mret
+ * Note: the hart will continue running on the same stack
+ */
+static inline void mode_set_and_jump(unsigned mode, void (*fn)(void))
+{
+    assert(mode <= PRV_U);
+    write_csr(mstatus, set_field(read_csr(mstatus), MSTATUS_MPP, mode));
+    write_csr(mepc, fn);
+    mret();
+}
+
+/*
+ * mode_set_and_continue
+ *
+ * Set mstatus.mpp, sets mepc to instruction after mret and then issues mret
+ * Note: the hart will continue running on the same stack
+ */
+static inline void mode_set_and_continue(unsigned mode)
+{
+    assert(mode <= PRV_U);
+    write_csr(mstatus, set_field(read_csr(mstatus), MSTATUS_MPP, mode));
+    asm volatile (
+        "lla t0, 1f\n"
+        "csrw mepc, t0\n"
+        "mret\n"
+        "1:"
+        ::: "t0"
+    );
+}
+
+#ifdef __cplusplus
+}
+#endif

tests/invader/include/arch/riscv/pte.h

+#pragma once
+
+enum {
+    PTE_SHIFT_V   = 0,
+    PTE_SHIFT_R   = 1,
+    PTE_SHIFT_W   = 2,
+    PTE_SHIFT_X   = 3,
+    PTE_SHIFT_U   = 4,
+    PTE_SHIFT_G   = 5,
+    PTE_SHIFT_A   = 6,
+    PTE_SHIFT_D   = 7,
+    PTE_SHIFT_SW1 = 8,
+    PTE_SHIFT_SW2 = 9,
+    PTE_V         = 1 << PTE_SHIFT_V,
+    PTE_R         = 1 << PTE_SHIFT_R,
+    PTE_W         = 1 << PTE_SHIFT_W,
+    PTE_X         = 1 << PTE_SHIFT_X,
+    PTE_U         = 1 << PTE_SHIFT_U,
+    PTE_G         = 1 << PTE_SHIFT_G,
+    PTE_A         = 1 << PTE_SHIFT_A,
+    PTE_D         = 1 << PTE_SHIFT_D,
+    PTE_SW1       = 1 << PTE_SHIFT_SW1,
+    PTE_SW2       = 1 << PTE_SHIFT_SW2
+};
+
+enum {
+    SV32_LEVELS = 2,
+    SV32_LEVEL_BITS = 10,
+    SV32_PTE_SIZE = 4
+};
+
+union sv32_va {
+    uint32_t val;
+    struct {
+        uint32_t pg_off : 12;
+        uint32_t vpn    : 20;
+    } va;
+};
+
+union sv32_pa {
+    uint64_t val;
+    struct {
+        uint64_t pg_off  : 12;
+        uint64_t ppn     : 22;
+        uint64_t rsrv    : 30;
+    } pa;
+};
+
+union sv32_pte {
+    uint32_t val;
+    struct {
+        uint32_t flags   : 10;
+        uint32_t ppn     : 22;
+    } pte;
+};
+
+enum {
+    SV39_LEVELS = 3,
+    SV39_LEVEL_BITS = 9,
+    SV39_PTE_SIZE = 8
+};
+
+union sv39_va {
+    uint64_t val;
+    struct {
+        uint64_t pg_off  : 12;
+        uint64_t vpn     : 27;
+        uint64_t rsrv    : 25;
+    } va;
+};
+
+union sv39_pa {
+    uint64_t val;
+    struct {
+        uint64_t pg_off  : 12;
+        uint64_t ppn     : 44;
+        uint64_t rsrv    : 8;
+    } pa;
+};
+
+union sv39_pte {
+    uint64_t val;
+    struct {
+        uint64_t flags   : 10;
+        uint64_t ppn     : 44;
+        uint64_t rsrv    : 10;
+    } pte;
+};
+
+enum {
+    SV48_LEVELS = 4,
+    SV48_LEVEL_BITS = 9,
+    SV48_PTE_SIZE = 8
+};
+
+union sv48_va {
+    uint64_t val;
+    struct {
+        uint64_t pg_off  : 12;
+        uint64_t vpn     : 36;
+        uint64_t rsrv    : 16;
+    } va;
+};
+
+union sv48_pa {
+    uint64_t val;
+    struct {
+        uint64_t pg_off  : 12;
+        uint64_t ppn     : 44;
+        uint64_t rsrv    : 8;
+    } pa;
+};
+
+union sv48_pte {
+    uint64_t val;
+    struct {
+        uint64_t flags   : 10;
+        uint64_t ppn     : 44;
+        uint64_t rsrv    : 10;
+    } pte;
+};

tests/invader/include/arch/riscv/trap.h

+// See LICENSE for license details.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*trap_fn)(uintptr_t* regs, uintptr_t mcause, uintptr_t mepc);
+trap_fn get_trap_fn();
+void set_trap_fn(trap_fn fn);
+
+const char * riscv_excp_names[16];
+const char * riscv_intr_names[16];
+
+enum {
+  cause_misaligned_fetch     = 0,
+  cause_fault_fetch          = 1,
+  cause_illegal_instruction  = 2,
+  cause_breakpoint           = 3,
+  cause_misaligned_load      = 4,
+  cause_fault_load           = 5,
+  cause_misaligned_store     = 6,
+  cause_fault_store          = 7,
+  cause_user_ecall           = 8,
+  cause_supervisor_ecall     = 9,
+  cause_hypervisor_ecall     = 10,
+  cause_machine_ecall        = 11,
+  cause_exec_page_fault      = 12,
+  cause_load_page_fault      = 13,
+  cause_store_page_fault     = 15
+};
+
+enum {
+  intr_u_software           = 0,
+  intr_s_software           = 1,
+  intr_h_software           = 2,
+  intr_m_software           = 3,
+  intr_u_timer              = 4,
+  intr_s_timer              = 5,
+  intr_h_timer              = 6,
+  intr_m_timer              = 7,
+  intr_u_external           = 8,
+  intr_s_external           = 9,
+  intr_h_external           = 10,
+  intr_m_external           = 11,
+};
+
+#ifdef __cplusplus
+}
+#endif

tests/invader/include/auxval.h

+// See LICENSE for license details.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+    HART0_CLOCK_FREQ           = 0x00010000,
+    UART0_CLOCK_FREQ           = 0x00011000,
+    UART0_BAUD_RATE            = 0x00011100,
+    NS16550A_UART0_CTRL_ADDR   = 0x00030000,
+    RISCV_HTIF_BASE_ADDR       = 0x00050000,
+    SIFIVE_CLINT_CTRL_ADDR     = 0x55550000,
+    SIFIVE_CLIC_CRTL_ADDR      = 0x55550001,
+    SIFIVE_TEST_CTRL_ADDR      = 0x55550002,
+    SIFIVE_UART0_CTRL_ADDR     = 0x55550010,
+    SIFIVE_GPIO0_CTRL_ADDR     = 0x55550020,
+    SIFIVE_SPI0_CTRL_ADDR      = 0x55550030,
+};
+
+typedef struct auxval {
+    unsigned long key;
+    unsigned long val;
+} auxval_t;
+
+extern auxval_t __auxv[];
+
+unsigned long getauxval(unsigned long key);
+
+#ifdef __cplusplus
+}
+#endif

tests/invader/include/device.h

+// See LICENSE for license details.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct console_device {
+    void (*init)();
+    int (*getchar)();
+    int (*putchar)(int);
+} console_device_t;
+
+typedef struct poweroff_device {
+    void (*init)();
+    void (*poweroff)(int);
+} poweroff_device_t;
+
+void register_console(console_device_t *dev);
+void register_poweroff(poweroff_device_t *dev);
+
+extern console_device_t *console_dev;
+extern poweroff_device_t *poweroff_dev;
+
+extern console_device_t console_none;
+extern console_device_t console_htif;
+extern console_device_t console_ns16550a;
+extern console_device_t console_sifive_uart;
+extern console_device_t console_semihost;
+
+extern poweroff_device_t poweroff_none;
+extern poweroff_device_t poweroff_htif;
+extern poweroff_device_t poweroff_sifive_test;
+extern poweroff_device_t poweroff_semihost;
+
+#ifdef __cplusplus
+}
+#endif

tests/invader/include/elf.h

+#pragma once
+
+#include <stdint.h>
+
+typedef uint32_t Elf32_Addr;
+typedef uint16_t Elf32_Half;
+typedef uint32_t Elf32_Off;
+typedef int32_t  Elf32_Sword;
+typedef uint32_t Elf32_Word;
+typedef uint8_t  Elf32_Byte;
+
+typedef uint64_t Elf64_Addr;
+typedef uint16_t Elf64_Half;
+typedef uint64_t Elf64_Off;
+typedef int32_t  Elf64_Sword;
+typedef uint32_t Elf64_Word;
+typedef uint64_t Elf64_Xword;
+typedef int64_t  Elf64_Sxword;
+typedef uint8_t  Elf64_Byte;
+
+enum {
+	AT_NULL = 0,
+	AT_PHDR = 3,
+	AT_PHENT = 4,
+	AT_PHNUM = 5,
+	AT_PAGESZ = 6,
+	AT_BASE = 7,
+	AT_FLAGS = 8,
+	AT_ENTRY = 9,
+	AT_UID = 11,
+	AT_EUID = 12,
+	AT_GID = 13,
+	AT_EGID  = 14,
+	AT_CLKTCK = 17,
+	AT_SECURE = 23,
+	AT_RANDOM = 25
+};
+
+typedef struct {
+	Elf32_Word a_type;
+	Elf32_Word a_val;
+} Elf32_auxv;
+
+typedef struct {
+	Elf64_Word a_type;
+	Elf64_Word a_val;
+} Elf64_auxv;
+
+enum {
+	ET_NONE = 0,
+	ET_REL = 1,
+	ET_EXEC = 2,
+	ET_DYN = 3,
+	ET_CORE = 4,
+	ET_LOPROC = 0xff00,
+	ET_HIPROC = 0xffff
+};
+
+enum {
+	EM_NONE = 0,
+	EM_X86_64 = 62,
+	EM_RISCV = 243
+};
+
+enum {
+	EV_NONE = 0,
+	EV_CURRENT = 1
+};
+
+enum {
+	EI_MAG0 = 0,
+	EI_MAG1 = 1,
+	EI_MAG2 = 2,
+	EI_MAG3 = 3,
+	EI_CLASS = 4,
+	EI_DATA = 5,
+	EI_VERSION = 6,
+	EI_OSABI = 7,
+	EI_ABIVERSION = 8,
+	EI_PAD = 9,
+	EI_NIDENT = 16
+};
+
+enum {
+	ELFMAG0 = 0x7f,
+	ELFMAG1 = 'E',
+	ELFMAG2 = 'L',
+	ELFMAG3 = 'F'
+};
+
+enum {
+	ELFCLASSNONE = 0,
+	ELFCLASS32 = 1,
+	ELFCLASS64 = 2,
+	ELFCLASS128 = 3
+};
+
+enum {
+	ELFDATANONE = 0,
+	ELFDATA2LSB = 1,
+	ELFDATA2MSB = 2
+};
+
+enum {
+	ELFOSABI_SYSV = 0,
+	ELFOSABI_LINUX = 3,
+	ELFOSABI_SOLARIS = 6,
+	ELFOSABI_FREEBSD = 9
+};
+
+enum {
+	ELFABIVERSION_NONE = 0
+};
+
+typedef struct {
+	Elf32_Byte  e_ident[EI_NIDENT];
+	Elf32_Half  e_type;
+	Elf32_Half  e_machine;
+	Elf32_Word  e_version;
+	Elf32_Addr  e_entry;
+	Elf32_Off   e_phoff;
+	Elf32_Off   e_shoff;
+	Elf32_Word  e_flags;
+	Elf32_Half  e_ehsize;
+	Elf32_Half  e_phentsize;
+	Elf32_Half  e_phnum;
+	Elf32_Half  e_shentsize;
+	Elf32_Half  e_shnum;
+	Elf32_Half  e_shstrndx;
+} Elf32_Ehdr;
+
+typedef struct {
+	Elf64_Byte  e_ident[EI_NIDENT];
+	Elf64_Half  e_type;
+	Elf64_Half  e_machine;
+	Elf64_Word  e_version;
+	Elf64_Addr  e_entry;
+	Elf64_Off   e_phoff;
+	Elf64_Off   e_shoff;
+	Elf64_Word  e_flags;
+	Elf64_Half  e_ehsize;
+	Elf64_Half  e_phentsize;
+	Elf64_Half  e_phnum;
+	Elf64_Half  e_shentsize;
+	Elf64_Half  e_shnum;
+	Elf64_Half  e_shstrndx;
+} Elf64_Ehdr;
+
+enum {
+	PT_NULL = 0,
+	PT_LOAD = 1,
+	PT_DYNAMIC = 2,
+	PT_INTERP = 3,
+	PT_NOTE = 4,
+	PT_SHLIB = 5,
+	PT_PHDR = 6,
+	PT_TLS = 7,
+	PT_LOOS = 0x60000000,
+	PT_GNU_EH_FRAME = 0x6474e550,
+	PT_GNU_STACK = 0x6474e551,
+	PT_GNU_RELRO = 0x6474e552,
+	PT_HIOS = 0x6fffffff,
+	PT_LOPROC = 0x70000000,
+	PT_HIPROC = 0x7fffffff
+};
+
+enum {
+	PF_X = 0x1,
+	PF_W = 0x2,
+	PF_R = 0x4,
+	PF_MASKOS = 0x00FF0000,
+	PF_MASKPROC = 0xFF000000,
+};
+
+typedef struct {
+	Elf32_Word  p_type;
+	Elf32_Off   p_offset;
+	Elf32_Addr  p_vaddr;
+	Elf32_Addr  p_paddr;
+	Elf32_Word  p_filesz;
+	Elf32_Word  p_memsz;
+	Elf32_Word  p_flags;
+	Elf32_Word  p_align;
+} Elf32_Phdr;
+
+typedef struct {
+	Elf64_Word  p_type;
+	Elf64_Word  p_flags;
+	Elf64_Off   p_offset;
+	Elf64_Addr  p_vaddr;
+	Elf64_Addr  p_paddr;
+	Elf64_Xword p_filesz;
+	Elf64_Xword p_memsz;
+	Elf64_Xword p_align;
+} Elf64_Phdr;
+
+enum {
+	SHN_UNDEF = 0,
+	SHN_LOPROC = 0xff00,
+	SHN_HIPROC = 0xff1f,
+	SHN_LOOS = 0xff20,
+	SHN_HIOS = 0xff3f,
+	SHN_ABS = 0xfff1,
+	SHN_COMMON = 0xfff2,
+	SHN_XINDEX = 0xffff,
+	SHN_HIRESERVE = 0xffff,
+};
+
+enum {
+	SHT_NULL = 0,
+	SHT_PROGBITS = 1,
+	SHT_SYMTAB = 2,
+	SHT_STRTAB = 3,
+	SHT_RELA = 4,
+	SHT_HASH = 5,
+	SHT_DYNAMIC = 6,
+	SHT_NOTE = 7,
+	SHT_NOBITS = 8,
+	SHT_REL = 9,
+	SHT_SHLIB = 10,
+	SHT_DYNSYM = 11,
+	SHT_INIT_ARRAY = 14,
+	SHT_FINI_ARRAY = 15,
+	SHT_PREINIT_ARRAY = 16,
+	SHT_GROUP = 17,
+	SHT_SYMTAB_SHNDX = 18,
+	SHT_LOOS = 0x60000000,
+	SHT_GNU_VERDEF = 0x6ffffffd,
+	SHT_GNU_VERNEED = 0x6ffffffe,
+	SHT_GNU_VERSYM = 0x6fffffff,
+	SHT_HIOS = 0x6fffffff,
+	SHT_LOPROC = 0x70000000,
+	SHT_HIPROC = 0x7fffffff,
+	SHT_LOUSER = 0x80000000,
+	SHT_HIUSER = 0xffffffff
+};
+
+enum {
+	SHF_WRITE = 0x1,
+	SHF_ALLOC = 0x2,
+	SHF_EXECINSTR = 0x4,
+	SHF_MERGE = 0x10,
+	SHF_STRINGS = 0x20,
+	SHF_INFO_LINK = 0x40,
+	SHF_LINK_ORDER = 0x80,
+	SHF_GROUP = 0x200,
+	SHF_TLS = 0x400,
+	SHF_MASKOS = 0x0F000000,
+	SHF_MASKPROC = 0xf0000000
+};
+
+enum {
+  GRP_COMDAT = 0x1,
+  GRP_MASKOS = 0x0ff00000,
+  GRP_MASKPROC = 0xf0000000
+};
+
+typedef struct {
+	Elf32_Word  sh_name;
+	Elf32_Word  sh_type;
+	Elf32_Word  sh_flags;
+	Elf32_Addr  sh_addr;
+	Elf32_Off   sh_offset;
+	Elf32_Word  sh_size;
+	Elf32_Word  sh_link;
+	Elf32_Word  sh_info;
+	Elf32_Word  sh_addralign;
+	Elf32_Word  sh_entsize;
+} Elf32_Shdr;
+
+typedef struct {
+	Elf64_Word  sh_name;
+	Elf64_Word  sh_type;
+	Elf64_Xword sh_flags;
+	Elf64_Addr  sh_addr;
+	Elf64_Off   sh_offset;
+	Elf64_Xword sh_size;
+	Elf64_Word  sh_link;
+	Elf64_Word  sh_info;
+	Elf64_Xword sh_addralign;
+	Elf64_Xword sh_entsize;
+} Elf64_Shdr;
+
+
+typedef struct {
+	Elf32_Word n_namesz;
+	Elf32_Word n_descsz;
+	Elf32_Word n_type;
+} Elf32_Nhdr;
+
+typedef struct {
+	Elf64_Word n_namesz;
+	Elf64_Word n_descsz;
+	Elf64_Word n_type;
+} Elf64_Nhdr;
+
+static inline const Elf32_Byte ELF32_ST_BIND(Elf32_Word i) { return i >> 4; }
+static inline const Elf32_Byte ELF32_ST_TYPE(Elf32_Word i) { return i & 0xf; }
+static inline const Elf32_Byte ELF32_ST_INFO(Elf32_Word b, Elf32_Word t) { return (b << 4) | (t & 0xf); }
+
+static inline const Elf32_Byte ELF64_ST_BIND(Elf32_Word i) { return i >> 4; }
+static inline const Elf32_Byte ELF64_ST_TYPE(Elf32_Word i) { return i & 0xf; }
+static inline const Elf32_Byte ELF64_ST_INFO(Elf32_Word b, Elf32_Word t) { return (b << 4) | (t & 0xf); }
+
+enum {
+	STB_LOCAL = 0,
+	STB_GLOBAL = 1,
+	STB_WEAK = 2,
+	STB_LOOS = 10,
+	STB_HIOS = 12,
+	STB_LOPROC = 13,
+	STB_HIPROC = 15
+};
+
+enum {
+	STT_NOTYPE = 0,
+	STT_OBJECT = 1,
+	STT_FUNC = 2,
+	STT_SECTION = 3,
+	STT_FILE = 4,
+	STT_LOOS = 10,
+	STT_HIOS = 12,
+	STT_LOPROC = 13,
+	STT_HIPROC = 15
+};
+
+enum {
+	STV_DEFAULT = 0,
+	STV_INTERNAL = 1,
+	STV_HIDDEN = 2,
+	STV_PROTECTED = 3
+};
+
+typedef struct {
+	Elf32_Word  st_name;
+	Elf32_Addr  st_value;
+	Elf32_Word  st_size;
+	Elf32_Byte  st_info;
+	Elf32_Byte  st_other;
+	Elf32_Half  st_shndx;
+} Elf32_Sym;
+
+typedef struct {
+	Elf64_Word  st_name;
+	Elf64_Byte  st_info;
+	Elf64_Byte  st_other;
+	Elf64_Half  st_shndx;
+	Elf64_Addr  st_value;
+	Elf64_Xword st_size;
+} Elf64_Sym;
+
+static inline const Elf32_Word ELF32_R_SYM(Elf32_Word i) { return i >> 8; }
+static inline const Elf32_Word ELF32_R_TYPE(Elf32_Word i) { return i & 0xff; }
+static inline const Elf32_Word ELF32_R_INFO(Elf32_Word s, Elf32_Word t) { return (s << 8) | (t & 0xff); }
+
+static inline const Elf64_Xword ELF64_R_SYM(Elf64_Xword i) { return i >> 32; }
+static inline const Elf64_Xword ELF64_R_TYPE(Elf64_Xword i) { return i & 0xffffffffUL; }
+static inline const Elf64_Xword ELF64_R_INFO(Elf64_Xword s, Elf64_Xword t) { return (s << 32) | (t & 0xffffffffUL); }
+
+typedef struct {
+	Elf32_Addr  r_offset;
+	Elf32_Word  r_info;
+} Elf32_Rel;
+
+typedef struct {
+	Elf32_Addr  r_offset;
+	Elf32_Word  r_info;
+	Elf32_Sword r_addend;
+} Elf32_Rela;
+
+typedef struct
+{
+	Elf64_Addr  r_offset;
+	Elf64_Xword r_info;
+} Elf64_Rel;
+
+typedef struct
+{
+	Elf64_Addr r_offset;
+	Elf64_Xword r_info;
+	Elf64_Sxword r_addend;
+} Elf64_Rela;
+
+enum {
+	R_X86_64_NONE = 0,
+	R_X86_64_64 = 1,
+	R_X86_64_PC32 = 2,
+	R_X86_64_GOT32 = 3,
+	R_X86_64_PLT32 = 4,
+	R_X86_64_COPY = 5,
+	R_X86_64_GLOB_DAT = 6,
+	R_X86_64_JUMP_SLOT = 7,
+	R_X86_64_RELATIVE = 8,
+	R_X86_64_GOTPCREL = 9,
+	R_X86_64_32 = 10,
+	R_X86_64_32S = 11,
+	R_X86_64_16 = 12,
+	R_X86_64_PC16 = 13,
+	R_X86_64_8 = 14,
+	R_X86_64_PC8 = 15,
+	R_X86_64_DTPMOD64 = 16,
+	R_X86_64_DTPOFF64 = 17,
+	R_X86_64_TPOFF64  = 18,
+	R_X86_64_TLSGD = 19,
+	R_X86_64_TLSLD = 20,
+	R_X86_64_DTPOFF32 = 21,
+	R_X86_64_GOTTPOFF = 22,
+	R_X86_64_TPOFF32 = 23,
+	R_X86_64_PC64 = 24,
+	R_X86_64_GOTOFF64 = 25,
+	R_X86_64_GOTPC32 = 26,
+	R_X86_64_SIZE32 = 32,
+	R_X86_64_SIZE64 = 33,
+	R_X86_64_GOTPC32_TLSDESC = 34,
+	R_X86_64_TLSDESC_CALL = 35,
+	R_X86_64_TLSDESC = 36,
+	R_X86_64_IRELATIVE = 37,
+	R_X86_64_RELATIVE64 = 38
+};
+
+enum {
+	R_RISCV_NONE = 0,
+	R_RISCV_32 = 1,
+	R_RISCV_64 = 2,
+	R_RISCV_RELATIVE = 3,
+	R_RISCV_COPY = 4,
+	R_RISCV_JUMP_SLOT = 5,
+	R_RISCV_TLS_DTPMOD32 = 6,
+	R_RISCV_TLS_DTPMOD64 = 7,
+	R_RISCV_TLS_DTPREL32 = 8,
+	R_RISCV_TLS_DTPREL64 = 9,
+	R_RISCV_TLS_TPREL32 = 10,
+	R_RISCV_TLS_TPREL64 = 11,
+	R_RISCV_BRANCH = 16,
+	R_RISCV_JAL = 17,
+	R_RISCV_CALL = 18,
+	R_RISCV_CALL_PLT = 19,
+	R_RISCV_GOT_HI20 = 20,
+	R_RISCV_TLS_GOT_HI20 = 21,
+	R_RISCV_TLS_GD_HI20 = 22,
+	R_RISCV_PCREL_HI20 = 23,
+	R_RISCV_PCREL_LO12_I = 24,
+	R_RISCV_PCREL_LO12_S = 25,
+	R_RISCV_HI20 = 26,
+	R_RISCV_LO12_I = 27,
+	R_RISCV_LO12_S = 28,
+	R_RISCV_TPREL_HI20 = 29,
+	R_RISCV_TPREL_LO12_I = 30,
+	R_RISCV_TPREL_LO12_S = 31,
+	R_RISCV_TPREL_ADD = 32,
+	R_RISCV_ADD8 = 33,
+	R_RISCV_ADD16 = 34,
+	R_RISCV_ADD32 = 35,
+	R_RISCV_ADD64 = 36,
+	R_RISCV_SUB8 = 37,
+	R_RISCV_SUB16 = 38,
+	R_RISCV_SUB32 = 39,
+	R_RISCV_SUB64 = 40,
+	R_RISCV_GNU_VTINHERIT = 41,
+	R_RISCV_GNU_VTENTRY = 42,
+	R_RISCV_ALIGN = 43,
+	R_RISCV_RVC_BRANCH = 44,
+	R_RISCV_RVC_JUMP = 45,
+	R_RISCV_RVC_LUI = 46,
+	R_RISCV_GPREL_I = 47,
+	R_RISCV_GPREL_S = 48,
+	R_RISCV_TPREL_I = 49,
+	R_RISCV_TPREL_S = 50,
+	R_RISCV_RELAX = 51,
+	R_RISCV_SUB6 = 52,
+	R_RISCV_SET6 = 53,
+	R_RISCV_SET8 = 54,
+	R_RISCV_SET16 = 55,
+	R_RISCV_SET32 = 56,
+};
+
+enum {
+	EF_RISCV_RVC = 0x1,
+	EF_RISCV_FLOAT_ABI_SINGLE = 0x2,
+	EF_RISCV_FLOAT_ABI_DOUBLE = 0x4,
+	EF_RISCV_FLOAT_ABI_QUAD = 0x6,
+	EF_RISCV_RVE = 0x8
+};
+
+enum {
+	DF_ORIGIN = 1,
+	DF_SYMBOLIC = 2,
+	DF_TEXTREL = 4,
+	DF_BIND_NOW = 8,
+	DF_STATIC_TLS = 16
+};
+
+enum {
+	DT_NULL = 0,
+	DT_NEEDED = 1,
+	DT_PLTRELSZ = 2,
+	DT_PLTGOT = 3,
+	DT_HASH = 4,
+	DT_STRTAB = 5,
+	DT_SYMTAB = 6,
+	DT_RELA = 7,
+	DT_RELASZ = 8,
+	DT_RELAENT = 9,
+	DT_STRSZ = 10,
+	DT_SYMENT = 11,
+	DT_INIT = 12,
+	DT_FINI = 13,
+	DT_SONAME = 14,
+	DT_RPATH = 15,
+	DT_SYMBOLIC = 16,
+	DT_REL = 17,
+	DT_RELSZ = 18,
+	DT_RELENT = 19,
+	DT_PLTREL = 20,
+	DT_DEBUG = 21,
+	DT_TEXTREL = 22,
+	DT_JMPREL = 23,
+	DT_BIND_NOW = 24,
+	DT_INIT_ARRAY = 25,
+	DT_FINI_ARRAY = 26,
+	DT_INIT_ARRAYSZ = 27,
+	DT_FINI_ARRAYSZ = 28,
+	DT_RUNPATH = 29,
+	DT_FLAGS = 30,
+	DT_LOOS = 0x60000000,
+	DT_HIOS = 0x6fffffff,
+	DT_LOPROC = 0x70000000,
+	DT_HIPROC = 0x7fffffff
+};
+
+typedef struct {
+	Elf32_Sword  d_tag;
+	union {
+		Elf32_Word  d_val;
+		Elf32_Addr  d_ptr;
+	} d_un;
+} Elf32_Dyn;
+
+typedef struct {
+	Elf64_Sxword d_tag;
+	union {
+		Elf64_Xword d_val;
+		Elf64_Addr  d_ptr;
+	} d_un;
+} Elf64_Dyn;

tests/invader/include/endian.h

+#pragma once
+
+#define bswap16(x) __builtin_bswap16(x)
+#define bswap32(x) __builtin_bswap32(x)
+#define bswap64(x) __builtin_bswap64(x)
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+static inline uint16_t htobe16(uint16_t x) { return bswap16(x); }
+static inline uint16_t htole16(uint16_t x) { return x; }
+static inline uint16_t be16toh(uint16_t x) { return bswap16(x); }
+static inline uint16_t le16toh(uint16_t x) { return x; }
+
+static inline uint32_t htobe32(uint32_t x) { return bswap32(x); }
+static inline uint32_t htole32(uint32_t x) { return x; }
+static inline uint32_t be32toh(uint32_t x) { return bswap32(x); }
+static inline uint32_t le32toh(uint32_t x) { return x; }
+
+static inline uint64_t htobe64(uint64_t x) { return bswap64(x); }
+static inline uint64_t htole64(uint64_t x) { return x; }
+static inline uint64_t be64toh(uint64_t x) { return bswap64(x); }
+static inline uint64_t le64toh(uint64_t x) { return x; }
+#elif __BYTE_ORDER == __BIG_ENDIAN
+static inline uint16_t htobe16(uint16_t x) { return x; }
+static inline uint16_t htole16(uint16_t x) { return bswap16(x); }
+static inline uint16_t be16toh(uint16_t x) { return x; }
+static inline uint16_t le16toh(uint16_t x) { return bswap16(x); }
+
+static inline uint32_t htobe32(uint32_t x) { return x; }
+static inline uint32_t htole32(uint32_t x) { return bswap32(x); }
+static inline uint32_t be32toh(uint32_t x) { return x; }
+static inline uint32_t le32toh(uint16_t x) { return bswap64(x); }
+
+static inline uint64_t htobe64(uint64_t x) { return x; }
+static inline uint64_t htole64(uint64_t x) { return bswap64(x); }
+static inline uint64_t be64toh(uint64_t x) { return x; }
+static inline uint64_t le64toh(uint64_t x) { return bswap64(x); }
+#endif
+
+#if __SIZE_WIDTH__ == 32
+#define _htobel htobe32
+#define _beltoh be32toh
+#define _htolel htole32
+#define _leltoh le32toh
+#endif
+
+#if __SIZE_WIDTH__ == 64
+#define _htobel htobe64
+#define _beltoh be64toh
+#define _htolel htole64
+#define _leltoh le64toh
+#endif
+
+#define htobe(X) _Generic((X),                \
+                 short: htobe16,              \
+                 unsigned short: htobe16,     \
+                 int: htobe32,                \
+                 unsigned int: htobe32,       \
+                 long: _htobel,               \
+                 unsigned long: _htobel,      \
+                 long long: htobe64,          \
+                 unsigned long long: htobe64  \
+                 )(X)
+
+#define betoh(X) _Generic((X),                \
+                 short: be16toh,              \
+                 unsigned short: be16toh,     \
+                 int: be32toh,                \
+                 unsigned int: be32toh,       \
+                 long: _beltoh,               \
+                 unsigned long: _beltoh,      \
+                 long long: be64toh,          \
+                 unsigned long long: be64toh  \
+                 )(X)
+
+#define htole(X) _Generic((X),                \
+                 short: htole16,              \
+                 unsigned short: htole16,     \
+                 int: htole32,                \
+                 unsigned int: htole32,       \
+                 long: _htolel,               \
+                 unsigned long: _htolel,      \
+                 long long: htole64,          \
+                 unsigned long long: htole64  \
+                 )(X)
+
+#define letoh(X) _Generic((X),                \
+                 short: le16toh,              \
+                 unsigned short: le16toh,     \
+                 int: le32toh,                \
+                 unsigned int: le32toh,       \
+                 long: _leltoh,               \
+                 unsigned long: _leltoh,      \
+                 long long: le64toh,          \
+                 unsigned long long: le64toh  \
+                 )(X)

tests/invader/include/femto.h

+// See LICENSE for license details.
+
+#pragma once
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdbits.h>
+#include <string.h>
+
+#include "auxval.h"
+#include "device.h"

tests/invader/include/font.h

+#ifndef FONT_H
+#define FONT_H
+/**
+ * 8x8 monochrome bitmap fonts for rendering
+ * Author: Daniel Hepper <daniel@hepper.net>
+ *
+ * License: Public Domain
+ *
+ * Based on:
+ * // Summary: font8x8.h
+ * // 8x8 monochrome bitmap fonts for rendering
+ * //
+ * // Author:
+ * //     Marcel Sondaar
+ * //     International Business Machines (public domain VGA fonts)
+ * //
+ * // License:
+ * //     Public Domain
+ *
+ * Fetched from: http://dimensionalrift.homelinux.net/combuster/mos3/?p=viewsource&file=/modules/gfx/font8_8.asm
+ * Fetched from github : https://github.com/dhepper/font8x8/blob/master/font8x8_basic.h
+ **/
+
+// Constant: font8x8_basic
+// Contains an 8x8 font map for unicode points U+0000 - U+007F (basic latin)
+extern char font8x8_basic[256][8];
+
+#endif

tests/invader/include/libscreen.h

+#ifndef LIBSCREEN
+#define LIBSCREEN
+
+typedef unsigned int uint;
+#include "font.h"
+#include "femto.h"
+
+#define CLINT_MSIP                      0x02000000
+#define CLINT_TIMER_CMP                 0x02004000
+#define CLINT_TIMER_CMP_HI              0x02004004
+#define CLINT_TIMER_CMP_LO              0x02004000
+#define CLINT_TIMER                     0x0200bff8
+#define CLINT_TIMER_HI                  0x0200bffc
+#define CLINT_TIMER_LOW                 0x0200bff8
+
+
+
+volatile uint* IMG;
+volatile uint *push;
+volatile uint *timer;
+volatile uint *timer_cmp;
+
+/* function to get the state of push buttons */
+uint push_button_get(void);
+
+// Timer options
+#ifdef ENV_QEMU 
+#define TIMER_FREQ 10000000 // 10MHz
+#define RATIO 500  
+#else
+#define TIMER_FREQ 100000000 // 100MHz
+#define RATIO 200 
+#endif
+
+/* function to set the timer to be reached in period*time/100 in the future */
+void timer_set(uint period, uint time);
+
+/* function to wait for timer zero value */
+void timer_wait(void);
+
+void timer_set_and_wait(uint period, uint time);
+
+#define NBCOL 1920
+#define NBROW 1080
+
+uint fgcolor;
+uint bgcolor;
+
+void draw(uint color, uint x, uint y);
+
+void clear_screen(uint color);
+
+void draw_bitmap(char* bitmap);
+
+void newline();
+void tab();
+
+/* Counts the number of characters of current word. Will be used to break lines, if possible not in the middle of words. */
+uint num_characters_until_white(char* str);
+
+uint display_cur_x = 0;
+uint display_cur_y = 0;
+uint display_scale = 16;
+
+void display_uint(uint i);
+void display_string(char* str);
+void set_fg_color(uint color);
+void set_bg_color(uint color);
+#endif

tests/invader/include/list.h

+/*
+ * Minimal Linux-like double-linked list helper functions
+ *
+ * Copyright (c) 2012-2016, Sven Eckelmann <sven@narfation.org>
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+/**
+ * container_of() - Calculate address of object that contains address ptr
+ * @ptr: pointer to member variable
+ * @type: type of the structure containing ptr
+ * @member: name of the member variable in struct @type
+ *
+ * Return: @type pointer of object containing ptr
+ */
+
+#define container_of(ptr, type, member) __extension__ ({ \
+	const __typeof__(((type *)0)->member) *__pmember = (ptr); \
+	(type *)((char *)__pmember - offsetof(type, member)); })
+
+/**
+ * struct list_head - Head and node of a double-linked list
+ * @prev: pointer to the previous node in the list
+ * @next: pointer to the next node in the list
+ *
+ * The simple double-linked list consists of a head and nodes attached to
+ * this head. Both node and head share the same struct type. The list_*
+ * functions and macros can be used to access and modify this data structure.
+ *
+ * The @prev pointer of the list head points to the last list node of the
+ * list and @next points to the first list node of the list. For an empty list,
+ * both member variables point to the head.
+ *
+ * The list nodes are usually embedded in a container structure which holds the
+ * actual data. Such an container object is called entry. The helper list_entry
+ * can be used to calculate the object address from the address of the node.
+ */
+struct list_head {
+	struct list_head *prev;
+	struct list_head *next;
+};
+
+/**
+ * LIST_HEAD - Declare list head and initialize it
+ * @head: name of the new object
+ */
+#define LIST_HEAD(head) \
+	struct list_head head = { &(head), &(head) }
+
+/**
+ * INIT_LIST_HEAD() - Initialize empty list head
+ * @head: pointer to list head
+ *
+ * This can also be used to initialize a unlinked list node.
+ *
+ * A node is usually linked inside a list, will be added to a list in
+ * the near future or the entry containing the node will be free'd soon.
+ *
+ * But an unlinked node may be given to a function which uses list_del(_init)
+ * before it ends up in a previously mentioned state. The list_del(_init) on an
+ * initialized node is well defined and safe. But the result of a
+ * list_del(_init) on an uninitialized node is undefined (unrelated memory is
+ * modified, crashes, ...).
+ */
+static __inline__ void INIT_LIST_HEAD(struct list_head *head)
+{
+	head->next = head;
+	head->prev = head;
+}
+
+/**
+ * list_add() - Add a list node to the beginning of the list
+ * @node: pointer to the new node
+ * @head: pointer to the head of the list
+ */
+static __inline__ void list_add(struct list_head *node,
+				struct list_head *head)
+{
+	struct list_head *next = head->next;
+
+	next->prev = node;
+	node->next = next;
+	node->prev = head;
+	head->next = node;
+}
+
+/**
+ * list_add_tail() - Add a list node to the end of the list
+ * @node: pointer to the new node
+ * @head: pointer to the head of the list
+ */
+static __inline__ void list_add_tail(struct list_head *node,
+				     struct list_head *head)
+{
+	struct list_head *prev = head->prev;
+
+	prev->next = node;
+	node->next = head;
+	node->prev = prev;
+	head->prev = node;
+}
+
+/**
+ * list_add_before() - Add a list node before another node to the list
+ * @new_node: pointer to the new node
+ * @node: pointer to the reference node in the list
+ *
+ * WARNING this functionality is not available in the Linux list implementation
+ */
+#define list_add_before(new_node, node) \
+	list_add_tail(new_node, node)
+
+/**
+ * list_add_behind() - Add a list node behind another node to the list
+ * @new_node: pointer to the new node
+ * @node: pointer to the reference node in the list
+ *
+ * WARNING this functionality is not available in the Linux list implementation
+ */
+#define list_add_behind(new_node, node) \
+	list_add(new_node, node)
+
+/**
+ * list_del() - Remove a list node from the list
+ * @node: pointer to the node
+ *
+ * The node is only removed from the list. Neither the memory of the removed
+ * node nor the memory of the entry containing the node is free'd. The node
+ * has to be handled like an uninitialized node. Accessing the next or prev
+ * pointer of the node is not safe.
+ *
+ * Unlinked, initialized nodes are also uninitialized after list_del.
+ *
+ * LIST_POISONING can be enabled during build-time to provoke an invalid memory
+ * access when the memory behind the next/prev pointer is used after a list_del.
+ * This only works on systems which prohibit access to the predefined memory
+ * addresses.
+ */
+static __inline__ void list_del(struct list_head *node)
+{
+	struct list_head *next = node->next;
+	struct list_head *prev = node->prev;
+
+	next->prev = prev;
+	prev->next = next;
+
+#ifdef LIST_POISONING
+	node->prev = (struct list_head *)(0x00100100);
+	node->next = (struct list_head *)(0x00200200);
+#endif
+}
+
+/**
+ * list_del_init() - Remove a list node from the list and reinitialize it
+ * @node: pointer to the node
+ *
+ * The removed node will not end up in an uninitialized state like when using
+ * list_del. Instead the node is initialized again to the unlinked state.
+ */
+static __inline__ void list_del_init(struct list_head *node)
+{
+	list_del(node);
+	INIT_LIST_HEAD(node);
+}
+
+/**
+ * list_empty() - Check if list head has no nodes attached
+ * @head: pointer to the head of the list
+ *
+ * Return: 0 - list is not empty !0 - list is empty
+ */
+static __inline__ int list_empty(const struct list_head *head)
+{
+	return (head->next == head);
+}
+
+/**
+ * list_is_singular() - Check if list head has exactly one node attached
+ * @head: pointer to the head of the list
+ *
+ * Return: 0 - list is not singular !0 -list has exactly one entry
+ */
+static __inline__ int list_is_singular(const struct list_head *head)
+{
+	return (!list_empty(head) && head->prev == head->next);
+}
+
+/**
+ * list_splice() - Add list nodes from a list to beginning of another list
+ * @list: pointer to the head of the list with the node entries
+ * @head: pointer to the head of the list
+ *
+ * All nodes from @list are added to to the beginning of the list of @head.
+ * It is similar to list_add but for multiple nodes. The @list head is not
+ * modified and has to be initialized to be used as a valid list head/node
+ * again.
+ */
+static __inline__ void list_splice(struct list_head *list,
+				   struct list_head *head)
+{
+	struct list_head *head_first = head->next;
+	struct list_head *list_first = list->next;
+	struct list_head *list_last = list->prev;
+
+	if (list_empty(list))
+		return;
+
+	head->next = list_first;
+	list_first->prev = head;
+
+	list_last->next = head_first;
+	head_first->prev = list_last;
+}
+
+/**
+ * list_splice_tail() - Add list nodes from a list to end of another list
+ * @list: pointer to the head of the list with the node entries
+ * @head: pointer to the head of the list
+ *
+ * All nodes from @list are added to to the end of the list of @head.
+ * It is similar to list_add_tail but for multiple nodes. The @list head is not
+ * modified and has to be initialized to be used as a valid list head/node
+ * again.
+ */
+static __inline__ void list_splice_tail(struct list_head *list,
+					struct list_head *head)
+{
+	struct list_head *head_last = head->prev;
+	struct list_head *list_first = list->next;
+	struct list_head *list_last = list->prev;
+
+	if (list_empty(list))
+		return;
+
+	head->prev = list_last;
+	list_last->next = head;
+
+	list_first->prev = head_last;
+	head_last->next = list_first;
+}
+
+/**
+ * list_splice_init() - Move list nodes from a list to beginning of another list
+ * @list: pointer to the head of the list with the node entries
+ * @head: pointer to the head of the list
+ *
+ * All nodes from @list are added to to the beginning of the list of @head.
+ * It is similar to list_add but for multiple nodes.
+ *
+ * The @list head will not end up in an uninitialized state like when using
+ * list_splice. Instead the @list is initialized again to the an empty
+ * list/unlinked state.
+ */
+static __inline__ void list_splice_init(struct list_head *list,
+					struct list_head *head)
+{
+	list_splice(list, head);
+	INIT_LIST_HEAD(list);
+}
+
+/**
+ * list_splice_tail_init() - Move list nodes from a list to end of another list
+ * @list: pointer to the head of the list with the node entries
+ * @head: pointer to the head of the list
+ *
+ * All nodes from @list are added to to the end of the list of @head.
+ * It is similar to list_add_tail but for multiple nodes.
+ *
+ * The @list head will not end up in an uninitialized state like when using
+ * list_splice. Instead the @list is initialized again to the an empty
+ * list/unlinked state.
+ */
+static __inline__ void list_splice_tail_init(struct list_head *list,
+					     struct list_head *head)
+{
+	list_splice_tail(list, head);
+	INIT_LIST_HEAD(list);
+}
+
+/**
+ * list_cut_position() - Move beginning of a list to another list
+ * @head_to: pointer to the head of the list which receives nodes
+ * @head_from: pointer to the head of the list
+ * @node: pointer to the node in which defines the cutting point
+ *
+ * All entries from the beginning of the list @head_from to (including) the
+ * @node is moved to @head_from.
+ *
+ * @head_to is replaced when @head_from is not empty. @node must be a real
+ * list node from @head_from or the behavior is undefined.
+ */
+static __inline__ void list_cut_position(struct list_head *head_to,
+					 struct list_head *head_from,
+					 struct list_head *node)
+{
+	struct list_head *head_from_first = head_from->next;
+
+	if (list_empty(head_from))
+		return;
+
+	if (head_from == node) {
+		INIT_LIST_HEAD(head_to);
+		return;
+	}
+
+	head_from->next = node->next;
+	head_from->next->prev = head_from;
+
+	head_to->prev = node;
+	node->next = head_to;
+	head_to->next = head_from_first;
+	head_to->next->prev = head_to;
+}
+
+/**
+ * list_move() - Move a list node to the beginning of the list
+ * @node: pointer to the node
+ * @head: pointer to the head of the list
+ *
+ * The @node is removed from its old position/node and add to the beginning of
+ * @head
+ */
+static __inline__ void list_move(struct list_head *node, struct list_head *head)
+{
+	list_del(node);
+	list_add(node, head);
+}
+
+/**
+ * list_move_tail() - Move a list node to the end of the list
+ * @node: pointer to the node
+ * @head: pointer to the head of the list
+ *
+ * The @node is removed from its old position/node and add to the end of @head
+ */
+static __inline__ void list_move_tail(struct list_head *node,
+				      struct list_head *head)
+{
+	list_del(node);
+	list_add_tail(node, head);
+}
+
+/**
+ * list_entry() - Calculate address of entry that contains list node
+ * @node: pointer to list node
+ * @type: type of the entry containing the list node
+ * @member: name of the list_head member variable in struct @type
+ *
+ * Return: @type pointer of entry containing node
+ */
+#define list_entry(node, type, member) container_of(node, type, member)
+
+/**
+ * list_first_entry() - get first entry of the list
+ * @head: pointer to the head of the list
+ * @type: type of the entry containing the list node
+ * @member: name of the list_head member variable in struct @type
+ *
+ * Return: @type pointer of first entry in list
+ */
+#define list_first_entry(head, type, member) \
+	list_entry((head)->next, type, member)
+
+/**
+ * list_last_entry() - get last entry of the list
+ * @head: pointer to the head of the list
+ * @type: type of the entry containing the list node
+ * @member: name of the list_head member variable in struct @type
+ *
+ * Return: @type pointer of last entry in list
+ */
+#define list_last_entry(head, type, member) \
+	list_entry((head)->prev, type, member)
+
+/**
+ * list_for_each - iterate over list nodes
+ * @node: list_head pointer used as iterator
+ * @head: pointer to the head of the list
+ *
+ * The nodes and the head of the list must must be kept unmodified while
+ * iterating through it. Any modifications to the the list will cause undefined
+ * behavior.
+ */
+#define list_for_each(node, head) \
+	for (node = (head)->next; \
+	     node != (head); \
+	     node = node->next)
+
+/**
+ * list_for_each_entry_t - iterate over list entries
+ * @entry: @type pointer used as iterator
+ * @head: pointer to the head of the list
+ * @type: type of the entries containing the list nodes
+ * @member: name of the list_head member variable in struct @type
+ *
+ * The nodes and the head of the list must must be kept unmodified while
+ * iterating through it. Any modifications to the the list will cause undefined
+ * behavior.
+ *
+ * WARNING this functionality is not available in the Linux list implementation
+ */
+#define list_for_each_entry_t(entry, head, type, member) \
+	for (entry = list_entry((head)->next, type, member); \
+	     &entry->member != (head); \
+	     entry = list_entry(entry->member.next, type, member))
+
+/**
+ * list_for_each_entry - iterate over list entries
+ * @entry: pointer used as iterator
+ * @head: pointer to the head of the list
+ * @member: name of the list_head member variable in struct type of @entry
+ *
+ * The nodes and the head of the list must must be kept unmodified while
+ * iterating through it. Any modifications to the the list will cause undefined
+ * behavior.
+ */
+#define list_for_each_entry(entry, head, member) \
+	list_for_each_entry_t(entry, head, __typeof__(*entry), member)
+
+/**
+ * list_for_each_safe - iterate over list nodes and allow deletes
+ * @node: list_head pointer used as iterator
+ * @safe: list_head pointer used to store info for next entry in list
+ * @head: pointer to the head of the list
+ *
+ * The current node (iterator) is allowed to be removed from the list. Any
+ * other modifications to the the list will cause undefined behavior.
+ */
+#define list_for_each_safe(node, safe, head) \
+	for (node = (head)->next, safe = node->next; \
+	     node != (head); \
+	     node = safe, safe = node->next)
+
+/**
+ * list_for_each_entry_safe_t - iterate over list entries and allow deletes
+ * @entry: @type pointer used as iterator
+ * @safe: @type pointer used to store info for next entry in list
+ * @head: pointer to the head of the list
+ * @type: type of the entries containing the list nodes
+ * @member: name of the list_head member variable in struct @type
+ *
+ * The current node (iterator) is allowed to be removed from the list. Any
+ * other modifications to the the list will cause undefined behavior.
+ *
+ * WARNING this functionality is not available in the Linux list implementation
+ */
+#define list_for_each_entry_safe_t(entry, safe, head, type, member) \
+	for (entry = list_entry((head)->next, type, member), \
+	     safe = list_entry(entry->member.next, type, member); \
+	     &entry->member != (head); \
+	     entry = safe, \
+	     safe = list_entry(safe->member.next, type, member))
+
+/**
+ * list_for_each_entry_safe - iterate over list entries and allow deletes
+ * @entry: pointer used as iterator
+ * @safe: @type pointer used to store info for next entry in list
+ * @head: pointer to the head of the list
+ * @member: name of the list_head member variable in struct type of @entry
+ *
+ * The current node (iterator) is allowed to be removed from the list. Any
+ * other modifications to the the list will cause undefined behavior.
+ */
+#define list_for_each_entry_safe(entry, safe, head, member) \
+	list_for_each_entry_safe_t(entry, safe, head, __typeof__(*entry), \
+				   member)
+
+#ifdef __cplusplus
+}
+#endif

tests/invader/include/stdarg.h

+#pragma once
+
+typedef __builtin_va_list va_list;
+
+#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 va_copy(d,s)    __builtin_va_copy(d,s)

tests/invader/include/stdbits.h

+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define clz(val) ({                         \
+    int result;                             \
+    switch(sizeof(val)) {                   \
+    case 1: result = clz8(val); break;      \
+    case 2: result = clz16(val); break;     \
+    case 4: result = clz32(val); break;     \
+    case 8: result = clz64(val); break;     \
+    }                                       \
+    result;                                 \
+})
+
+#define ctz(val) ({                         \
+    int result;                             \
+    switch(sizeof(val)) {                   \
+    case 1: result = ctz8(val); break;      \
+    case 2: result = ctz16(val); break;     \
+    case 4: result = ctz32(val); break;     \
+    case 8: result = ctz64(val); break;     \
+    }                                       \
+    result;                                 \
+})
+
+int clz8(int8_t val);
+int clz16(int16_t val);
+int clz32(int32_t val);
+int clz64(int64_t val);
+
+int ctz8(int8_t val);
+int ctz16(int16_t val);
+int ctz32(int32_t val);
+int ctz64(int64_t val);
+
+static inline int ispow2(uintptr_t val)
+{
+    return val && !(val & (val-1));
+}
+
+static inline uintptr_t roundpow2(uintptr_t val)
+{
+    val--;
+    val |= val >> 1;
+    val |= val >> 2;
+    val |= val >> 4;
+    val |= val >> 8;
+    val |= val >> 16;
+#if __SIZE_WIDTH__ == 64
+    val |= val >> 32;
+#endif
+    val++;
+    return val;
+}
+
+#ifdef __cplusplus
+}
+#endif

tests/invader/include/stddef.h

+#pragma once
+
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+typedef __SIZE_TYPE__ size_t;
+typedef __WCHAR_TYPE__ wchar_t;
+
+#define NULL 0L
+#define offsetof(type, member) __builtin_offsetof(type, member)

tests/invader/include/stdint.h

+#pragma once
+
+typedef __INT8_TYPE__ int8_t;
+typedef __INT16_TYPE__ int16_t;
+typedef __INT32_TYPE__ int32_t;
+typedef __INT64_TYPE__ int64_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 __INT_LEAST16_TYPE__ int_least16_t;
+typedef __INT_LEAST32_TYPE__ int_least32_t;
+typedef __INT_LEAST64_TYPE__ int_least64_t;
+typedef __INT_LEAST8_TYPE__ int_least8_t;
+
+typedef __INTMAX_TYPE__ intmax_t;
+typedef __INTPTR_TYPE__ intptr_t;
+
+typedef __UINT8_TYPE__ uint8_t;
+typedef __UINT16_TYPE__ uint16_t;
+typedef __UINT32_TYPE__ uint32_t;
+typedef __UINT64_TYPE__ uint64_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 __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 __UINTMAX_TYPE__ uintmax_t;
+typedef __UINTPTR_TYPE__ uintptr_t;
+
+#define INT8_MAX __INT8_MAX__
+#define INT16_MAX __INT16_MAX__
+#define INT32_MAX __INT32_MAX__
+#define INT64_MAX __INT64_MAX__
+
+#define UINT8_MAX  __UINT8_MAX__
+#define UINT16_MAX __UINT16_MAX__
+#define UINT32_MAX __UINT32_MAX__
+#define UINT64_MAX __UINT64_MAX__
+
+#define INTPTR_MAX __INTPTR_MAX__
+#define UINTPTR_MAX __UINTPTR_MAX__
+#define PTRDIFF_MAX __PTRDIFF_MAX__
+#define SIZE_MAX __SIZE_MAX__

tests/invader/include/stdio.h

+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+#include <stddef.h>
+
+int getchar(void);
+int printf(const char *, ...);
+int putchar(int);
+int puts(const char *);
+int snprintf(char *, size_t, const char *, ...);
+int vprintf(const char *, va_list);
+int vsnprintf(char *, size_t, const char *, va_list);
+
+#ifdef __cplusplus
+}
+#endif

tests/invader/include/stdlib.h

+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+__attribute__((noreturn)) void abort(void);
+__attribute__((noreturn)) void exit(int status);
+void* malloc(size_t size);
+void free(void* ptr);
+void _malloc_addblock(void* addr, size_t size);
+
+#ifdef __cplusplus
+}
+#endif

tests/invader/include/string.h

+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+
+void *memchr(const void *s, int c, size_t n);
+int memcmp(const void *, const void *, size_t);
+void *memcpy(void *, const void *, size_t);
+void *memset(void *, int, size_t);
+char *strchr(const char *s, int c);
+int strcmp(const char *, const char *);
+size_t strlen(const char *);
+int strncmp(const char *, const char *, size_t);
+char *strncpy(char *, const char *, size_t);
+
+#ifdef __cplusplus
+}
+#endif