fixes stack pointer adjustment

CMakeLists.txt

@@ -2,8 +2,10 @@ cmake_minimum_required(VERSION 3.21)
 include(CheckLinkerFlag)
 
 project(mnrs-bsp LANGUAGES ASM C)
+option(NO_INIT "use an empty init routine" OFF)
 set(LINKER_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/env/${BOARD}/link.lds"
     CACHE FILEPATH "Linker script to use for BSP linking")
+get_filename_component(LINKER_SCRIPT_DIR "${LINKER_SCRIPT}" DIRECTORY)
 set(BSP_STARTUP "${CMAKE_CURRENT_SOURCE_DIR}/env/start.S"
     CACHE FILEPATH "Path to the BSP startup assembly file")
 set(BSP_TRAP_HANDLER "${CMAKE_CURRENT_SOURCE_DIR}/env/entry.S"
@@ -29,18 +31,22 @@ target_include_directories(startup PUBLIC env include)
 
 add_subdirectory(libwrap)
 
-add_library(bsp STATIC env/${BOARD}/init.c)
-target_link_libraries(bsp PUBLIC startup wrap)
-target_include_directories(bsp PUBLIC env/${BOARD})
+add_library(runtime STATIC env/${BOARD}/init.c)
+target_include_directories(runtime PUBLIC env/${BOARD} env include)
+if(NO_INIT)
+    target_compile_definitions(runtime PRIVATE NO_INIT)
+endif()
 
 check_linker_flag(C "LINKER:--no-warn-rwx-segments" HAS_NO_WARN_RWX_SEGMENTS)
-
 if(HAS_NO_WARN_RWX_SEGMENTS)
-    target_link_options(bsp INTERFACE LINKER:--no-warn-rwx-segments)
+    target_link_options(runtime INTERFACE LINKER:--no-warn-rwx-segments)
 endif()
-target_link_options(bsp INTERFACE LINKER: -nostartfiles -T ${LINKER_SCRIPT})
+target_link_options(runtime INTERFACE LINKER: -nostartfiles -T ${LINKER_SCRIPT} -L${LINKER_SCRIPT_DIR})
 
 if(SEMIHOSTING)
-    target_include_directories(bsp INTERFACE include)
-    target_sources(bsp INTERFACE env/semihosting.c env/trap.c)
+    target_sources(runtime INTERFACE env/semihosting.c env/trap.c)
 endif()
+
+add_library(bsp INTERFACE)
+target_link_libraries(bsp INTERFACE startup runtime wrap)
+

env/entry.S

@@ -10,12 +10,13 @@
   .align 2
   .global trap_entry
 trap_entry:
-  addi sp, sp, -32*REGBYTES
+#ifdef __riscv_abi_rve
+  addi sp, sp, -12*REGBYTES
+#else
+  addi sp, sp, -28*REGBYTES
+#endif
 
   sw  x1,  1*REGBYTES(sp)
-  sw  x2,  2*REGBYTES(sp)
-  sw  x3,  3*REGBYTES(sp)
-  sw  x4,  4*REGBYTES(sp)
   sw  x5,  5*REGBYTES(sp)
   sw  x6,  6*REGBYTES(sp)
   sw  x7,  7*REGBYTES(sp)
@@ -53,9 +54,6 @@ trap_entry:
 
 
   lw  x1,  1*REGBYTES(sp)
-  lw  x2,  2*REGBYTES(sp)
-  lw  x3,  3*REGBYTES(sp)
-  lw  x4,  4*REGBYTES(sp)
   lw  x5,  5*REGBYTES(sp)
   lw  x6,  6*REGBYTES(sp)
   lw  x7,  7*REGBYTES(sp)
@@ -84,6 +82,9 @@ trap_entry:
   lw x29, 29*REGBYTES(sp)
   lw x30, 30*REGBYTES(sp)
   lw x31, 31*REGBYTES(sp)
+  addi sp, sp, 28*REGBYTES
+#else
+  addi sp, sp, 12*REGBYTES
 #endif
   mret
 

env/riscv_vp/init.c

@@ -2,18 +2,14 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#include "platform.h"
 #include "encoding.h"
-
+#include "platform.h"
 
 extern int main(int argc, char** argv);
 extern void trap_entry(void);
-#define IRQ_M_SOFT   3
-#define IRQ_M_TIMER  7
-#define IRQ_M_EXT    11
-
-#define NUM_INTERRUPTS 16
-#define MTIMER_NEXT_TICK_INC 1000
+#define IRQ_M_SOFT 3
+#define IRQ_M_TIMER 7
+#define IRQ_M_EXT 11
 
 void handle_m_ext_interrupt(void);
 void handle_m_time_interrupt(void);
@@ -21,118 +17,94 @@ uint32_t handle_trap(uint32_t mcause, uint32_t mepc, uint32_t sp);
 void default_handler(void);
 void _init(void);
 
-typedef void (*my_interrupt_function_ptr_t) (void);
+typedef void (*my_interrupt_function_ptr_t)(void);
 my_interrupt_function_ptr_t localISR[NUM_INTERRUPTS] __attribute__((aligned(64)));
 
-static unsigned long mtime_lo(void)
-{
+static unsigned long mtime_lo(void) {
     unsigned long ret;
-    __asm volatile("rdtime %0":"=r"(ret));
+    __asm volatile("rdtime %0" : "=r"(ret));
     return ret;
 }
 
+#if __riscv_xlen == 32
 
-#if __riscv_xlen==32
-
-static uint32_t mtime_hi(void)
-{
+static uint32_t mtime_hi(void) {
     unsigned long ret;
-    __asm volatile("rdtimeh %0":"=r"(ret));
+    __asm volatile("rdtimeh %0" : "=r"(ret));
     return ret;
 }
 
-uint64_t get_timer_value(void)
-{
-  while (1) {
-    uint32_t hi = mtime_hi();
-    uint32_t lo = mtime_lo();
-    if (hi == mtime_hi())
-      return ((uint64_t)hi << 32) | lo;
-  }
-}
-
-#elif __riscv_xlen==64
-
-uint64_t get_timer_value()
-{
-  return mtime_lo();
-}
-
-#endif
-
-unsigned long get_timer_freq()
-{
-  return 32768;
-}
-
-unsigned long get_cpu_freq()
-{
-  return 100000000;
-}
-
-void init_pll(void){
-    //TODO: implement initialization
-}
-
-static void uart_init(size_t baud_rate)
-{
-  //TODO: implement initialization
-}
-
-void __attribute__((weak)) handle_m_ext_interrupt(){
-}
-
-void __attribute__((weak)) handle_m_time_interrupt(){
-  uint64_t time = get_aclint_mtime(aclint);
-  time+=MTIMER_NEXT_TICK_INC;
-  set_aclint_mtimecmp(aclint, time);
-}
-
-void __attribute__((weak)) default_handler(void) {
-  puts("default handler\n");
-}
-
-void __attribute__((weak)) interrupt_handler(unsigned) {
-  puts("interrupt handler\n");
-}
-
-uint32_t handle_trap(uint32_t mcause, uint32_t mepc, uint32_t sp){
-  if ((mcause & MCAUSE_INT)) {
-    if ((mcause & MCAUSE_CAUSE) == IRQ_M_EXT) {
-      handle_m_ext_interrupt();
-    } else if (((mcause & MCAUSE_CAUSE) == IRQ_M_TIMER)){ 
-      handle_m_time_interrupt();
-    } else {
-      interrupt_handler(mcause& ~MCAUSE_INT);
+uint64_t get_timer_value(void) {
+    while(1) {
+        uint32_t hi = mtime_hi();
+        uint32_t lo = mtime_lo();
+        if(hi == mtime_hi())
+            return ((uint64_t)hi << 32) | lo;
     }
-  } else {
-    write(1, "trap\n", 5);
-    _exit(1 + mcause);
-  }
-  return mepc;
 }
 
-void _init()
-{
-  
-#ifndef NO_INIT
-  init_pll();
-  uart_init(115200);
-  printf("core freq at %lu Hz\n", get_cpu_freq());
-  write_csr(mtvec, &trap_entry);
-  if (read_csr(misa) & (1 << ('F' - 'A'))) { // if F extension is present
-    write_csr(mstatus, MSTATUS_FS); // allow FPU instructions without trapping
-    write_csr(fcsr, 0); // initialize rounding mode, undefined at reset
-  }
-  int i=0;
-  while(i<NUM_INTERRUPTS)  {
-    localISR[i++] = default_handler;
-  }
+#elif __riscv_xlen == 64
+
+uint64_t get_timer_value() { return mtime_lo(); }
 
 #endif
-  
+
+unsigned long get_timer_freq() { return 32768; }
+
+unsigned long get_cpu_freq() { return 100000000; }
+
+void init_pll(void) {
+    // TODO: implement initialization
 }
 
-void _fini(void)
-{
+static void uart_init(size_t baud_rate) {
+    // TODO: implement initialization
 }
+
+void __attribute__((weak)) handle_m_ext_interrupt() {}
+
+void __attribute__((weak)) handle_m_time_interrupt() {
+    uint64_t time = get_aclint_mtime(aclint);
+    time += MTIMER_NEXT_TICK_INC;
+    set_aclint_mtimecmp(aclint, time);
+}
+
+void __attribute__((weak)) default_handler(void) { puts("default handler\n"); }
+
+void __attribute__((weak)) interrupt_handler(unsigned) { puts("interrupt handler\n"); }
+
+uint32_t handle_trap(uint32_t mcause, uint32_t mepc, uint32_t sp) {
+    if((mcause & MCAUSE_INT)) {
+        if((mcause & MCAUSE_CAUSE) == IRQ_M_EXT) {
+            handle_m_ext_interrupt();
+        } else if(((mcause & MCAUSE_CAUSE) == IRQ_M_TIMER)) {
+            handle_m_time_interrupt();
+        } else {
+            interrupt_handler(mcause & ~MCAUSE_INT);
+        }
+    } else {
+        write(1, "trap\n", 5);
+        _exit(1 + mcause);
+    }
+    return mepc;
+}
+
+void __attribute__((weak)) _init() {
+#ifndef NO_INIT
+    init_pll();
+    uart_init(115200);
+    printf("core freq at %lu Hz\n", get_cpu_freq());
+    write_csr(mtvec, &trap_entry);
+    if(read_csr(misa) & (1 << ('F' - 'A'))) { // if F extension is present
+        write_csr(mstatus, MSTATUS_FS);       // allow FPU instructions without trapping
+        write_csr(fcsr, 0);                   // initialize rounding mode, undefined at reset
+    }
+    int i = 0;
+    while(i < NUM_INTERRUPTS) {
+        localISR[i++] = default_handler;
+    }
+
+#endif
+}
+
+void _fini(void) {}

env/riscv_vp/memory_map.ld

@@ -1,7 +1,7 @@
 MEMORY
 {
   ram   (wxa!ri) : ORIGIN = 0x00000000, LENGTH = 128K
-  rom   (rxai!w) : ORIGIN = 0x1000E000, LENGTH = 2k
+  rom   (rxai!w) : ORIGIN = 0x10080000, LENGTH = 8k
   flash (rxai!w) : ORIGIN = 0x20000000, LENGTH = 16M
   dram  (wxa!ri) : ORIGIN = 0x40000000, LENGTH = 2048M
 }

env/riscv_vp/platform.h

@@ -21,10 +21,11 @@
 #include "minres/devices/qspi.h"
 #include "minres/devices/timer.h"
 #include "minres/devices/uart.h"
+#include <riscv/riscv_csr.h>
 
 #define PERIPH(TYPE, ADDR) ((volatile TYPE*)(ADDR))
 // values from memory_map.ld
-#define XIP_START_LOC 0x30000000
+#define XIP_START_LOC 0x20000000
 #define RAM_START_LOC 0x00000000
 #define APB_BASE 0x10000000
 
@@ -41,6 +42,9 @@
 
 #include <stdint.h>
 
+#define NUM_INTERRUPTS 16
+#define MTIMER_NEXT_TICK_INC 1000
+
 void init_pll(void);
 unsigned long get_cpu_freq(void);
 unsigned long get_timer_freq(void);

env/start.S

@@ -60,7 +60,7 @@ _start:
 	fssr x0
 1:
 #endif
-
+	call _init
 	/* argc = argv = 0 */
 	li a0, 0
 	li a1, 0

include/minres/devices/aclint.h

@@ -1,27 +1,36 @@
 #ifndef _DEVICES_ACLINT_H
 #define _DEVICES_ACLINT_H
 
-#include <stdint.h>
 #include "gen/aclint.h"
+#include <stdint.h>
 
-
-static void set_aclint_mtime(volatile aclint_t* reg, uint64_t value){
+static void set_aclint_mtime(volatile aclint_t* reg, uint64_t value) {
     set_aclint_mtime_hi(reg, (uint32_t)(value >> 32));
     set_aclint_mtime_lo(reg, (uint32_t)value);
 }
 
-static uint64_t get_aclint_mtime(volatile aclint_t* reg){
-    uint64_t value = ((uint64_t)get_aclint_mtime_hi(reg) << 32) | (uint64_t)get_aclint_mtime_lo(reg);
-    return value;
+static uint64_t get_aclint_mtime(volatile aclint_t* reg) {
+    // #if ( __riscv_xlen == 64)
+    //     volatile uint64_t *mtime = (volatile uint64_t *)(RISCV_MTIME_ADDR);
+    //     return *mtime;
+    // #else
+    uint32_t mtimeh_val;
+    uint32_t mtimel_val;
+    do {
+        mtimeh_val = get_aclint_mtime_hi(reg);
+        mtimel_val = get_aclint_mtime_lo(reg);
+    } while(mtimeh_val != get_aclint_mtime_hi(reg));
+    return (uint64_t)((((uint64_t)mtimeh_val) << 32) | mtimel_val);
+    // #endif
 }
 
-static void set_aclint_mtimecmp(volatile aclint_t* reg, uint64_t value){
+static void set_aclint_mtimecmp(volatile aclint_t* reg, uint64_t value) {
     set_aclint_mtimecmp0lo(reg, (uint32_t)0xFFFFFFFF);
     set_aclint_mtimecmp0hi(reg, (uint32_t)(value >> 32));
     set_aclint_mtimecmp0lo(reg, (uint32_t)value);
 }
 
-static uint64_t get_aclint_mtimecmp(volatile aclint_t* reg){
+static uint64_t get_aclint_mtimecmp(volatile aclint_t* reg) {
     uint64_t value = ((uint64_t)get_aclint_mtimecmp0hi(reg) << 32) | (uint64_t)get_aclint_mtimecmp0lo(reg);
     return value;
 }

libwrap/sys/puts.c

@@ -4,10 +4,12 @@
 
 extern ssize_t _bsp_write(int, const void*, size_t);
 
-int __wrap_puts(const char* s) {
-    const char* str = s;
-    while(*str)
-        str++;
-    return _bsp_write(STDOUT_FILENO, s, str - s);
+int __wrap_puts(const char* s) {    
+     if(!s) return -1;
+     const char* str = s;
+     while(*str) 
+          ++str;
+     *(char*)str='\n';
+     return _bsp_write(STDOUT_FILENO, s, (str - s)+1);   
 }
-weak_under_alias(puts);
+    weak_under_alias(puts);