benchmarks/common/syscalls.c

   1 // See LICENSE for license details.
   2
   3 #include <stdint.h>
   4 #include <string.h>
   5 #include <stdarg.h>
   6 #include <stdio.h>
   7 #include <limits.h>
   8 #include "util.h"
   9
  10 #define SYS_write 64
  11 #define SYS_exit 93
  12 #define SYS_stats 1234
  13
  14 extern volatile uint64_t tohost;
  15 extern volatile uint64_t fromhost;
  16
  17 static uintptr_t handle_frontend_syscall(uintptr_t which, uint64_t arg0, uint64_t arg1, uint64_t arg2)
  18 {
  19   volatile uint64_t magic_mem[8] __attribute__((aligned(64)));
  20   magic_mem[0] = which;
  21   magic_mem[1] = arg0;
  22   magic_mem[2] = arg1;
  23   magic_mem[3] = arg2;
  24   __sync_synchronize();
  25
  26   tohost = (uintptr_t)magic_mem;
  27   while (fromhost == 0)
  28     ;
  29   fromhost = 0;
  30
  31   __sync_synchronize();
  32   return magic_mem[0];
  33 }
  34
  35 #define NUM_COUNTERS 2
  36 static uintptr_t counters[NUM_COUNTERS];
  37 static char* counter_names[NUM_COUNTERS];
  38
  39 static int handle_stats(int enable)
  40 {
  41   int i = 0;
  42 #define READ_CTR(name) do { \
  43     while (i >= NUM_COUNTERS) ; \
  44     uintptr_t csr = read_csr(name); \
  45     if (!enable) { csr -= counters[i]; counter_names[i] = #name; } \
  46     counters[i++] = csr; \
  47   } while (0)
  48
  49   READ_CTR(mcycle);
  50   READ_CTR(minstret);
  51
  52 #undef READ_CTR
  53   return 0;
  54 }
  55
  56 void __attribute__((noreturn)) tohost_exit(uintptr_t code)
  57 {
  58   tohost = (code << 1) | 1;
  59   while (1);
  60 }
  61
  62 uintptr_t handle_trap(uintptr_t cause, uintptr_t epc, uintptr_t regs[32])
  63 {
  64   if (cause != CAUSE_MACHINE_ECALL)
  65     tohost_exit(1337);
  66   else if (regs[17] == SYS_exit)
  67     tohost_exit(regs[10]);
  68   else if (regs[17] == SYS_stats)
  69     regs[10] = handle_stats(regs[10]);
  70   else
  71     regs[10] = handle_frontend_syscall(regs[17], regs[10], regs[11], regs[12]);
  72
  73   return epc + ((*(unsigned short*)epc & 3) == 3 ? 4 : 2);
  74 }
  75
  76 static uintptr_t syscall(uintptr_t num, uintptr_t arg0, uintptr_t arg1, uintptr_t arg2)
  77 {
  78   register uintptr_t a7 asm("a7") = num;
  79   register uintptr_t a0 asm("a0") = arg0;
  80   register uintptr_t a1 asm("a1") = arg1;
  81   register uintptr_t a2 asm("a2") = arg2;
  82   asm volatile ("scall" : "+r"(a0) : "r"(a1), "r"(a2), "r"(a7));
  83   return a0;
  84 }
  85
  86 void exit(int code)
  87 {
  88   syscall(SYS_exit, code, 0, 0);
  89   while (1);
  90 }
  91
  92 void setStats(int enable)
  93 {
  94   syscall(SYS_stats, enable, 0, 0);
  95 }
  96
  97 void printstr(const char* s)
  98 {
  99   syscall(SYS_write, 1, (uintptr_t)s, strlen(s));
 100 }
 101
 102 void __attribute__((weak)) thread_entry(int cid, int nc)
 103 {
 104   // multi-threaded programs override this function.
 105   // for the case of single-threaded programs, only let core 0 proceed.
 106   while (cid != 0);
 107 }
 108
 109 int __attribute__((weak)) main(int argc, char** argv)
 110 {
 111   // single-threaded programs override this function.
 112   printstr("Implement main(), foo!\n");
 113   return -1;
 114 }
 115
 116 static void init_tls()
 117 {
 118   register void* thread_pointer asm("tp");
 119   extern char _tls_data;
 120   extern __thread char _tdata_begin, _tdata_end, _tbss_end;
 121   size_t tdata_size = &_tdata_end - &_tdata_begin;
 122   memcpy(thread_pointer, &_tls_data, tdata_size);
 123   size_t tbss_size = &_tbss_end - &_tdata_end;
 124   memset(thread_pointer + tdata_size, 0, tbss_size);
 125 }
 126
 127 void _init(int cid, int nc)
 128 {
 129   init_tls();
 130   thread_entry(cid, nc);
 131
 132   // only single-threaded programs should ever get here.
 133   int ret = main(0, 0);
 134
 135   char buf[NUM_COUNTERS * 32] __attribute__((aligned(64)));
 136   char* pbuf = buf;
 137   for (int i = 0; i < NUM_COUNTERS; i++)
 138     if (counters[i])
 139       pbuf += sprintf(pbuf, "%s = %d\n", counter_names[i], counters[i]);
 140   if (pbuf != buf)
 141     printstr(buf);
 142
 143   exit(ret);
 144 }
 145
 146 #undef putchar
 147 int putchar(int ch)
 148 {
 149   static __thread char buf[64] __attribute__((aligned(64)));
 150   static __thread int buflen = 0;
 151
 152   buf[buflen++] = ch;
 153
 154   if (ch == '\n' || buflen == sizeof(buf))
 155   {
 156     syscall(SYS_write, 1, (uintptr_t)buf, buflen);
 157     buflen = 0;
 158   }
 159
 160   return 0;
 161 }
 162
 163 void printhex(uint64_t x)
 164 {
 165   char str[17];
 166   int i;
 167   for (i = 0; i < 16; i++)
 168   {
 169     str[15-i] = (x & 0xF) + ((x & 0xF) < 10 ? '0' : 'a'-10);
 170     x >>= 4;
 171   }
 172   str[16] = 0;
 173
 174   printstr(str);
 175 }
 176
 177 static inline void printnum(void (*putch)(int, void**), void **putdat,
 178                     unsigned long long num, unsigned base, int width, int padc)
 179 {
 180   unsigned digs[sizeof(num)*CHAR_BIT];
 181   int pos = 0;
 182
 183   while (1)
 184   {
 185     digs[pos++] = num % base;
 186     if (num < base)
 187       break;
 188     num /= base;
 189   }
 190
 191   while (width-- > pos)
 192     putch(padc, putdat);
 193
 194   while (pos-- > 0)
 195     putch(digs[pos] + (digs[pos] >= 10 ? 'a' - 10 : '0'), putdat);
 196 }
 197
 198 static unsigned long long getuint(va_list *ap, int lflag)
 199 {
 200   if (lflag >= 2)
 201     return va_arg(*ap, unsigned long long);
 202   else if (lflag)
 203     return va_arg(*ap, unsigned long);
 204   else
 205     return va_arg(*ap, unsigned int);
 206 }
 207
 208 static long long getint(va_list *ap, int lflag)
 209 {
 210   if (lflag >= 2)
 211     return va_arg(*ap, long long);
 212   else if (lflag)
 213     return va_arg(*ap, long);
 214   else
 215     return va_arg(*ap, int);
 216 }
 217
 218 static void vprintfmt(void (*putch)(int, void**), void **putdat, const char *fmt, va_list ap)
 219 {
 220   register const char* p;
 221   const char* last_fmt;
 222   register int ch, err;
 223   unsigned long long num;
 224   int base, lflag, width, precision, altflag;
 225   char padc;
 226
 227   while (1) {
 228     while ((ch = *(unsigned char *) fmt) != '%') {
 229       if (ch == '\0')
 230         return;
 231       fmt++;
 232       putch(ch, putdat);
 233     }
 234     fmt++;
 235
 236     // Process a %-escape sequence
 237     last_fmt = fmt;
 238     padc = ' ';
 239     width = -1;
 240     precision = -1;
 241     lflag = 0;
 242     altflag = 0;
 243   reswitch:
 244     switch (ch = *(unsigned char *) fmt++) {
 245
 246     // flag to pad on the right
 247     case '-':
 248       padc = '-';
 249       goto reswitch;
 250
 251     // flag to pad with 0's instead of spaces
 252     case '0':
 253       padc = '0';
 254       goto reswitch;
 255
 256     // width field
 257     case '1':
 258     case '2':
 259     case '3':
 260     case '4':
 261     case '5':
 262     case '6':
 263     case '7':
 264     case '8':
 265     case '9':
 266       for (precision = 0; ; ++fmt) {
 267         precision = precision * 10 + ch - '0';
 268         ch = *fmt;
 269         if (ch < '0' || ch > '9')
 270           break;
 271       }
 272       goto process_precision;
 273
 274     case '*':
 275       precision = va_arg(ap, int);
 276       goto process_precision;
 277
 278     case '.':
 279       if (width < 0)
 280         width = 0;
 281       goto reswitch;
 282
 283     case '#':
 284       altflag = 1;
 285       goto reswitch;
 286
 287     process_precision:
 288       if (width < 0)
 289         width = precision, precision = -1;
 290       goto reswitch;
 291
 292     // long flag (doubled for long long)
 293     case 'l':
 294       lflag++;
 295       goto reswitch;
 296
 297     // character
 298     case 'c':
 299       putch(va_arg(ap, int), putdat);
 300       break;
 301
 302     // string
 303     case 's':
 304       if ((p = va_arg(ap, char *)) == NULL)
 305         p = "(null)";
 306       if (width > 0 && padc != '-')
 307         for (width -= strnlen(p, precision); width > 0; width--)
 308           putch(padc, putdat);
 309       for (; (ch = *p) != '\0' && (precision < 0 || --precision >= 0); width--) {
 310         putch(ch, putdat);
 311         p++;
 312       }
 313       for (; width > 0; width--)
 314         putch(' ', putdat);
 315       break;
 316
 317     // (signed) decimal
 318     case 'd':
 319       num = getint(&ap, lflag);
 320       if ((long long) num < 0) {
 321         putch('-', putdat);
 322         num = -(long long) num;
 323       }
 324       base = 10;
 325       goto signed_number;
 326
 327     // unsigned decimal
 328     case 'u':
 329       base = 10;
 330       goto unsigned_number;
 331
 332     // (unsigned) octal
 333     case 'o':
 334       // should do something with padding so it's always 3 octits
 335       base = 8;
 336       goto unsigned_number;
 337
 338     // pointer
 339     case 'p':
 340       static_assert(sizeof(long) == sizeof(void*));
 341       lflag = 1;
 342       putch('0', putdat);
 343       putch('x', putdat);
 344       /* fall through to 'x' */
 345
 346     // (unsigned) hexadecimal
 347     case 'x':
 348       base = 16;
 349     unsigned_number:
 350       num = getuint(&ap, lflag);
 351     signed_number:
 352       printnum(putch, putdat, num, base, width, padc);
 353       break;
 354
 355     // escaped '%' character
 356     case '%':
 357       putch(ch, putdat);
 358       break;
 359
 360     // unrecognized escape sequence - just print it literally
 361     default:
 362       putch('%', putdat);
 363       fmt = last_fmt;
 364       break;
 365     }
 366   }
 367 }
 368
 369 int printf(const char* fmt, ...)
 370 {
 371   va_list ap;
 372   va_start(ap, fmt);
 373
 374   vprintfmt((void*)putchar, 0, fmt, ap);
 375
 376   va_end(ap);
 377   return 0; // incorrect return value, but who cares, anyway?
 378 }
 379
 380 int sprintf(char* str, const char* fmt, ...)
 381 {
 382   va_list ap;
 383   char* str0 = str;
 384   va_start(ap, fmt);
 385
 386   void sprintf_putch(int ch, void** data)
 387   {
 388     char** pstr = (char**)data;
 389     **pstr = ch;
 390     (*pstr)++;
 391   }
 392
 393   vprintfmt(sprintf_putch, (void**)&str, fmt, ap);
 394   *str = 0;
 395
 396   va_end(ap);
 397   return str - str0;
 398 }
 399
 400 void* memcpy(void* dest, const void* src, size_t len)
 401 {
 402   if ((((uintptr_t)dest | (uintptr_t)src | len) & (sizeof(uintptr_t)-1)) == 0) {
 403     const uintptr_t* s = src;
 404     uintptr_t *d = dest;
 405     while (d < (uintptr_t*)(dest + len))
 406       *d++ = *s++;
 407   } else {
 408     const char* s = src;
 409     char *d = dest;
 410     while (d < (char*)(dest + len))
 411       *d++ = *s++;
 412   }
 413   return dest;
 414 }
 415
 416 void* memset(void* dest, int byte, size_t len)
 417 {
 418   if ((((uintptr_t)dest | len) & (sizeof(uintptr_t)-1)) == 0) {
 419     uintptr_t word = byte & 0xFF;
 420     word |= word << 8;
 421     word |= word << 16;
 422     word |= word << 16 << 16;
 423
 424     uintptr_t *d = dest;
 425     while (d < (uintptr_t*)(dest + len))
 426       *d++ = word;
 427   } else {
 428     char *d = dest;
 429     while (d < (char*)(dest + len))
 430       *d++ = byte;
 431   }
 432   return dest;
 433 }
 434
 435 size_t strlen(const char *s)
 436 {
 437   const char *p = s;
 438   while (*p)
 439     p++;
 440   return p - s;
 441 }
 442
 443 size_t strnlen(const char *s, size_t n)
 444 {
 445   const char *p = s;
 446   while (n-- && *p)
 447     p++;
 448   return p - s;
 449 }
 450
 451 int strcmp(const char* s1, const char* s2)
 452 {
 453   unsigned char c1, c2;
 454
 455   do {
 456     c1 = *s1++;
 457     c2 = *s2++;
 458   } while (c1 != 0 && c1 == c2);
 459
 460   return c1 - c2;
 461 }
 462
 463 char* strcpy(char* dest, const char* src)
 464 {
 465   char* d = dest;
 466   while ((*d++ = *src++))
 467     ;
 468   return dest;
 469 }
 470
 471 long atol(const char* str)
 472 {
 473   long res = 0;
 474   int sign = 0;
 475
 476   while (*str == ' ')
 477     str++;
 478
 479   if (*str == '-' || *str == '+') {
 480     sign = *str == '-';
 481     str++;
 482   }
 483
 484   while (*str) {
 485     res *= 10;
 486     res += *str++ - '0';
 487   }
 488
 489   return sign ? -res : res;
 490 }