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)
+add_library(runtime STATIC env/${BOARD}/init.c)
-target_link_libraries(bsp PUBLIC startup wrap)
+target_include_directories(runtime PUBLIC env/${BOARD} env include)
-target_include_directories(bsp PUBLIC env/${BOARD})
+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(runtime INTERFACE env/semihosting.c env/trap.c)
-    target_sources(bsp 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,9 +2,8 @@
 #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);
@@ -12,9 +11,6 @@ extern void trap_entry(void);
 #define IRQ_M_TIMER 7
 #define IRQ_M_EXT 11
 
-#define NUM_INTERRUPTS 16
-#define MTIMER_NEXT_TICK_INC 1000
-
 void handle_m_ext_interrupt(void);
 void handle_m_time_interrupt(void);
 uint32_t handle_trap(uint32_t mcause, uint32_t mepc, uint32_t sp);
@@ -24,25 +20,21 @@ void _init(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));
     return ret;
 }
 
-
 #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));
     return ret;
 }
 
-uint64_t get_timer_value(void)
+uint64_t get_timer_value(void) {
-{
     while(1) {
         uint32_t hi = mtime_hi();
         uint32_t lo = mtime_lo();
@@ -53,34 +45,23 @@ uint64_t get_timer_value(void)
 
 #elif __riscv_xlen == 64
 
-uint64_t get_timer_value()
+uint64_t get_timer_value() { return mtime_lo(); }
-{
-  return mtime_lo();
-}
 
 #endif
 
-unsigned long get_timer_freq()
+unsigned long get_timer_freq() { return 32768; }
-{
-  return 32768;
-}
 
-unsigned long get_cpu_freq()
+unsigned long get_cpu_freq() { return 100000000; }
-{
-  return 100000000;
-}
 
 void init_pll(void) {
     // TODO: implement initialization
 }
 
-static void uart_init(size_t baud_rate)
+static void uart_init(size_t baud_rate) {
-{
     // TODO: implement initialization
 }
 
-void __attribute__((weak)) handle_m_ext_interrupt(){
+void __attribute__((weak)) handle_m_ext_interrupt() {}
-}
 
 void __attribute__((weak)) handle_m_time_interrupt() {
     uint64_t time = get_aclint_mtime(aclint);
@@ -88,13 +69,9 @@ void __attribute__((weak)) handle_m_time_interrupt(){
     set_aclint_mtimecmp(aclint, time);
 }
 
-void __attribute__((weak)) default_handler(void) {
+void __attribute__((weak)) default_handler(void) { puts("default handler\n"); }
-  puts("default handler\n");
-}
 
-void __attribute__((weak)) interrupt_handler(unsigned) {
+void __attribute__((weak)) interrupt_handler(unsigned) { puts("interrupt handler\n"); }
-  puts("interrupt handler\n");
-}
 
 uint32_t handle_trap(uint32_t mcause, uint32_t mepc, uint32_t sp) {
     if((mcause & MCAUSE_INT)) {
@@ -112,9 +89,7 @@ uint32_t handle_trap(uint32_t mcause, uint32_t mepc, uint32_t sp){
     return mepc;
 }
 
-void _init()
+void __attribute__((weak)) _init() {
-{
-  
 #ifndef NO_INIT
     init_pll();
     uart_init(115200);
@@ -130,9 +105,6 @@ void _init()
     }
 
 #endif
-  
 }
 
-void _fini(void)
+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,9 +1,8 @@
 #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) {
     set_aclint_mtime_hi(reg, (uint32_t)(value >> 32));
@@ -11,8 +10,18 @@ static void set_aclint_mtime(volatile aclint_t* reg, uint64_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);
+    // #if ( __riscv_xlen == 64)
-    return value;
+    //     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) {

libwrap/sys/puts.c

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