X-Git-Url: https://git.libre-soc.org/?p=riscv-tests.git;a=blobdiff_plain;f=benchmarks%2Fcommon%2Fsyscalls.c;h=0a7d6b728f633304d9b3aa9e01ecb2b8ddf6f57c;hp=f95dde48adb7cbce7f122cf4eee67816eafcf305;hb=HEAD;hpb=23507d668862dff15a898f20e109a46c6e95780d

diff --git a/benchmarks/common/syscalls.c b/benchmarks/common/syscalls.c
index f95dde4..0a7d6b7 100644
--- a/benchmarks/common/syscalls.c
+++ b/benchmarks/common/syscalls.c
@@ -1,50 +1,139 @@
+// See LICENSE for license details.
+
 #include <stdint.h>
 #include <string.h>
 #include <stdarg.h>
-#include "pcr.h"
+#include <stdio.h>
+#include <limits.h>
+#include <sys/signal.h>
+#include "util.h"
 
-void exit(int code)
+#define SYS_write 64
+
+#undef strcmp
+
+extern volatile uint64_t tohost;
+extern volatile uint64_t fromhost;
+
+static uintptr_t syscall(uintptr_t which, uint64_t arg0, uint64_t arg1, uint64_t arg2)
 {
-  volatile uint64_t magic_mem[8] = {0};
-  magic_mem[0] = 1;
-  magic_mem[1] = code;
+  volatile uint64_t magic_mem[8] __attribute__((aligned(64)));
+  magic_mem[0] = which;
+  magic_mem[1] = arg0;
+  magic_mem[2] = arg1;
+  magic_mem[3] = arg2;
+  __sync_synchronize();
+
+  tohost = (uintptr_t)magic_mem;
+  while (fromhost == 0)
+    ;
+  fromhost = 0;
+
   __sync_synchronize();
-  mtpcr(PCR_TOHOST, (long)magic_mem);
-  while(1);
+  return magic_mem[0];
+}
+
+#define NUM_COUNTERS 2
+static uintptr_t counters[NUM_COUNTERS];
+static char* counter_names[NUM_COUNTERS];
+
+void setStats(int enable)
+{
+  int i = 0;
+#define READ_CTR(name) do { \
+    while (i >= NUM_COUNTERS) ; \
+    uintptr_t csr = read_csr(name); \
+    if (!enable) { csr -= counters[i]; counter_names[i] = #name; } \
+    counters[i++] = csr; \
+  } while (0)
+
+  READ_CTR(mcycle);
+  READ_CTR(minstret);
+
+#undef READ_CTR
+}
+
+void __attribute__((noreturn)) tohost_exit(uintptr_t code)
+{
+  tohost = (code << 1) | 1;
+  while (1);
+}
+
+uintptr_t __attribute__((weak)) handle_trap(uintptr_t cause, uintptr_t epc, uintptr_t regs[32])
+{
+  tohost_exit(1337);
+}
+
+void exit(int code)
+{
+  tohost_exit(code);
+}
+
+void abort()
+{
+  exit(128 + SIGABRT);
 }
 
 void printstr(const char* s)
 {
-  volatile uint64_t magic_mem[8] = {0};
-  magic_mem[0] = 4;
-  magic_mem[1] = 1;
-  magic_mem[2] = (unsigned long)s;
-  magic_mem[3] = strlen(s);
-  __sync_synchronize();
-  mtpcr(PCR_TOHOST, (long)magic_mem);
-  while(mtpcr(PCR_FROMHOST, 0) == 0);
+  syscall(SYS_write, 1, (uintptr_t)s, strlen(s));
+}
+
+void __attribute__((weak)) thread_entry(int cid, int nc)
+{
+  // multi-threaded programs override this function.
+  // for the case of single-threaded programs, only let core 0 proceed.
+  while (cid != 0);
+}
+
+int __attribute__((weak)) main(int argc, char** argv)
+{
+  // single-threaded programs override this function.
+  printstr("Implement main(), foo!\n");
+  return -1;
+}
+
+static void init_tls()
+{
+  register void* thread_pointer asm("tp");
+  extern char _tls_data;
+  extern __thread char _tdata_begin, _tdata_end, _tbss_end;
+  size_t tdata_size = &_tdata_end - &_tdata_begin;
+  memcpy(thread_pointer, &_tls_data, tdata_size);
+  size_t tbss_size = &_tbss_end - &_tdata_end;
+  memset(thread_pointer + tdata_size, 0, tbss_size);
 }
 
+void _init(int cid, int nc)
+{
+  init_tls();
+  thread_entry(cid, nc);
+
+  // only single-threaded programs should ever get here.
+  int ret = main(0, 0);
+
+  char buf[NUM_COUNTERS * 32] __attribute__((aligned(64)));
+  char* pbuf = buf;
+  for (int i = 0; i < NUM_COUNTERS; i++)
+    if (counters[i])
+      pbuf += sprintf(pbuf, "%s = %d\n", counter_names[i], counters[i]);
+  if (pbuf != buf)
+    printstr(buf);
+
+  exit(ret);
+}
+
+#undef putchar
 int putchar(int ch)
 {
-  #define buffered_putch_bufsize 64
-  static char buf[buffered_putch_bufsize];
-  static int buflen = 0;
+  static __thread char buf[64] __attribute__((aligned(64)));
+  static __thread int buflen = 0;
 
-  if(ch != -1)
-    buf[buflen++] = ch;
+  buf[buflen++] = ch;
 
-  if(ch == -1 || buflen == buffered_putch_bufsize)
+  if (ch == '\n' || buflen == sizeof(buf))
   {
-    volatile uint64_t magic_mem[8] = {0};
-    magic_mem[0] = 4;
-    magic_mem[1] = 1;
-    magic_mem[2] = (long)buf;
-    magic_mem[3] = buflen;
-    __sync_synchronize();
-    mtpcr(PCR_TOHOST, (long)magic_mem);
-    while(mtpcr(PCR_FROMHOST, 0) == 0);
-
+    syscall(SYS_write, 1, (uintptr_t)buf, buflen);
     buflen = 0;
   }
 
@@ -65,15 +154,25 @@ void printhex(uint64_t x)
   printstr(str);
 }
 
-static void printnum(void (*putch)(int, void**), void **putdat,
-                   unsigned long long num, unsigned base, int width, int padc)
+static inline void printnum(void (*putch)(int, void**), void **putdat,
+                    unsigned long long num, unsigned base, int width, int padc)
 {
-  if (num >= base)
-    printnum(putch, putdat, num / base, base, width - 1, padc);
-  else while (--width > 0)
+  unsigned digs[sizeof(num)*CHAR_BIT];
+  int pos = 0;
+
+  while (1)
+  {
+    digs[pos++] = num % base;
+    if (num < base)
+      break;
+    num /= base;
+  }
+
+  while (width-- > pos)
     putch(padc, putdat);
 
-  putch("0123456789abcdef"[num % base], putdat);
+  while (pos-- > 0)
+    putch(digs[pos] + (digs[pos] >= 10 ? 'a' - 10 : '0'), putdat);
 }
 
 static unsigned long long getuint(va_list *ap, int lflag)
@@ -96,7 +195,7 @@ static long long getint(va_list *ap, int lflag)
     return va_arg(*ap, int);
 }
 
-void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt, va_list ap)
+static void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt, va_list ap)
 {
   register const char* p;
   const char* last_fmt;
@@ -188,10 +287,7 @@ void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt, va_li
         for (width -= strnlen(p, precision); width > 0; width--)
           putch(padc, putdat);
       for (; (ch = *p) != '\0' && (precision < 0 || --precision >= 0); width--) {
-        if (altflag && (ch < ' ' || ch > '~'))
-          putch('?', putdat);
-        else
-          putch(ch, putdat);
+        putch(ch, putdat);
         p++;
       }
       for (; width > 0; width--)
@@ -206,35 +302,33 @@ void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt, va_li
         num = -(long long) num;
       }
       base = 10;
-      goto number;
+      goto signed_number;
 
     // unsigned decimal
     case 'u':
-      num = getuint(&ap, lflag);
       base = 10;
-      goto number;
+      goto unsigned_number;
 
     // (unsigned) octal
     case 'o':
       // should do something with padding so it's always 3 octits
-      num = getuint(&ap, lflag);
       base = 8;
-      goto number;
+      goto unsigned_number;
 
     // pointer
     case 'p':
+      static_assert(sizeof(long) == sizeof(void*));
+      lflag = 1;
       putch('0', putdat);
       putch('x', putdat);
-      num = (unsigned long long)
-        (uintptr_t) va_arg(ap, void *);
-      base = 16;
-      goto number;
+      /* fall through to 'x' */
 
     // (unsigned) hexadecimal
     case 'x':
-      num = getuint(&ap, lflag);
       base = 16;
-    number:
+    unsigned_number:
+      num = getuint(&ap, lflag);
+    signed_number:
       printnum(putch, putdat, num, base, width, padc);
       break;
 
@@ -258,8 +352,119 @@ int printf(const char* fmt, ...)
   va_start(ap, fmt);
 
   vprintfmt((void*)putchar, 0, fmt, ap);
-  putchar(-1);
 
   va_end(ap);
   return 0; // incorrect return value, but who cares, anyway?
 }
+
+int sprintf(char* str, const char* fmt, ...)
+{
+  va_list ap;
+  char* str0 = str;
+  va_start(ap, fmt);
+
+  void sprintf_putch(int ch, void** data)
+  {
+    char** pstr = (char**)data;
+    **pstr = ch;
+    (*pstr)++;
+  }
+
+  vprintfmt(sprintf_putch, (void**)&str, fmt, ap);
+  *str = 0;
+
+  va_end(ap);
+  return str - str0;
+}
+
+void* memcpy(void* dest, const void* src, size_t len)
+{
+  if ((((uintptr_t)dest | (uintptr_t)src | len) & (sizeof(uintptr_t)-1)) == 0) {
+    const uintptr_t* s = src;
+    uintptr_t *d = dest;
+    while (d < (uintptr_t*)(dest + len))
+      *d++ = *s++;
+  } else {
+    const char* s = src;
+    char *d = dest;
+    while (d < (char*)(dest + len))
+      *d++ = *s++;
+  }
+  return dest;
+}
+
+void* memset(void* dest, int byte, size_t len)
+{
+  if ((((uintptr_t)dest | len) & (sizeof(uintptr_t)-1)) == 0) {
+    uintptr_t word = byte & 0xFF;
+    word |= word << 8;
+    word |= word << 16;
+    word |= word << 16 << 16;
+
+    uintptr_t *d = dest;
+    while (d < (uintptr_t*)(dest + len))
+      *d++ = word;
+  } else {
+    char *d = dest;
+    while (d < (char*)(dest + len))
+      *d++ = byte;
+  }
+  return dest;
+}
+
+size_t strlen(const char *s)
+{
+  const char *p = s;
+  while (*p)
+    p++;
+  return p - s;
+}
+
+size_t strnlen(const char *s, size_t n)
+{
+  const char *p = s;
+  while (n-- && *p)
+    p++;
+  return p - s;
+}
+
+int strcmp(const char* s1, const char* s2)
+{
+  unsigned char c1, c2;
+
+  do {
+    c1 = *s1++;
+    c2 = *s2++;
+  } while (c1 != 0 && c1 == c2);
+
+  return c1 - c2;
+}
+
+char* strcpy(char* dest, const char* src)
+{
+  char* d = dest;
+  while ((*d++ = *src++))
+    ;
+  return dest;
+}
+
+long atol(const char* str)
+{
+  long res = 0;
+  int sign = 0;
+
+  while (*str == ' ')
+    str++;
+
+  if (*str == '-' || *str == '+') {
+    sign = *str == '-';
+    str++;
+  }
+
+  while (*str) {
+    res *= 10;
+    res += *str++ - '0';
+  }
+
+  return sign ? -res : res;
+}